Neural Network Processing Element Incorporating Compute And Local Memory Elements

ABSTRACT

A novel and useful neural network (NN) processing core adapted to implement artificial neural networks (ANNs) and incorporating processing circuits having compute and local memory elements. The NN processor is constructed from self-contained computational units organized in a hierarchical architecture. The homogeneity enables simpler management and control of similar computational units, aggregated in multiple levels of hierarchy. Computational units are designed with minimal overhead as possible, where additional features and capabilities are aggregated at higher levels in the hierarchy. On-chip memory provides storage for content inherently required for basic operation at a particular hierarchy and is coupled with the computational resources in an optimal ratio. Lean control provides just enough signaling to manage only the operations required at a particular hierarchical level. Dynamic resource assignment agility is provided which can be adjusted as required depending on resource availability and capacity of the device.

REFERENCE TO PRIORITY APPLICATIONS

This application claims the benefit of U.S. Provisional Application No.62/481,492, filed Apr. 4, 2017, entitled “Multi-Layer Artificial NeuralNetwork Computation Engine and Microarchitecture,” and U.S. ProvisionalApplication No. 62/531,372, filed Jul. 12, 2017, entitled “Multi-LayerArtificial Neural Network Computation Engine and Microarchitecture,”both of which are incorporated herein by reference in their entirety.

FIELD OF THE DISCLOSURE

The subject matter disclosed herein relates to the field of neuralnetworks and more particularly relates to a neural network (NN)processing engine incorporating processing circuits having compute andlocal memory elements and adapted to implement an artificial neuralnetwork (ANN).

BACKGROUND OF THE INVENTION

Artificial neural networks (ANNs) are computing systems inspired by thebiological neural networks that constitute animal brains. Such systemslearn, i.e. progressively improve performance, to do tasks byconsidering examples, generally without task-specific programming byextracting the critical features of those tasks and generalizing fromlarge numbers of examples. For example, in image recognition, they mightlearn to identify images that contain cats by analyzing example imagesthat have been manually labeled as “cat” or “not cat” and using theanalytic results to identify cats in other images. They have found mostuse in applications difficult to express in a traditional computeralgorithm using rule-based programming.

An ANN is based on a collection of connected units called artificialneurons, analogous to neurons in a biological brain. Each connection orsynapse between neurons can transmit a signal to another neuron. Thereceiving or postsynaptic neuron is connected to another one or severalneurons and can process the signals and then signal downstream neuronsconnected to it through a synapse also referred to as an axon. Neuronsmay have state, generally represented by real numbers, typically between0 and 1. Neurons and synapses may also have a weight that varies aslearning proceeds, which can increase or decrease the strength of thesignal that it sends downstream. Further, they may have a threshold suchthat only if the aggregate signal is below or above that level is thedownstream signal sent.

Typically, neurons are organized in layers. Different layers may performdifferent kinds of transformations on their inputs. Signals travel fromthe first, i.e. input, to the last, i.e. output, layer, possibly aftertraversing the layers multiple times.

The original goal of the neural network approach was to solve problemsin the same way that a human brain would. Over time, attention focusedon matching specific mental abilities, leading to deviations frombiology such as backpropagation, or passing information in the reversedirection and adjusting the network to reflect that information.

The components of an artificial neural network include (1) neuronshaving an activation threshold; (2) connections and weights fortransferring the output of a neuron; (3) a propagation function tocompute the input to a neuron from the output of predecessor neurons;and (4) a learning rule which is an algorithm that modifies theparameters of the neural network in order for a given input to produce adesired outcome which typically amounts to modifying the weights andthresholds.

Given a specific task to solve, and a class of functions F, learningentails using a set of observations to find the function that whichsolves the task in some optimal sense. A cost function C is defined suchthat, for the optimal solution no other solution has a cost less thanthe cost of the optimal solution).

The cost function C is a measure of how far away a particular solutionis from an optimal solution to the problem to be solved. Learningalgorithms search through the solution space to find a function that hasthe smallest possible cost.

A neural network can be trained using backpropagation which is a methodto calculate the gradient of the loss function with respect to theweights in an ANN. The weight updates of backpropagation can be done viawell-known stochastic gradient descent techniques. Note that the choiceof the cost function depends on factors such as the learning type (e.g.,supervised, unsupervised, reinforcement) and the activation function.

There are three major learning paradigms and each corresponds to aparticular learning task: supervised learning, unsupervised learning,and reinforcement learning. Supervised learning uses a set of examplepairs and the goal is to find a function in the allowed class offunctions that matches the examples. A commonly used cost is themean-squared error, which tries to minimize the average squared errorbetween the network's output and the target value over all examplepairs. Minimizing this cost using gradient descent for the class ofneural networks called multilayer perceptrons (MLP), produces thebackpropagation algorithm for training neural networks. Examples ofsupervised learning include pattern recognition, i.e. classification,and regression, i.e. function approximation.

In unsupervised learning, some data is given and the cost function to beminimized, that can be any function of the data and the network'soutput. The cost function is dependent on the task (i.e. the modeldomain) and any a priori assumptions (i.e. the implicit properties ofthe model, its parameters, and the observed variables). Tasks that fallwithin the paradigm of unsupervised learning are in general estimationproblems; the applications include clustering, the estimation ofstatistical distributions, compression, and filtering.

In reinforcement learning, data is usually not provided, but generatedby an agent's interactions with the environment. At each point in time,the agent performs an action and the environment generates anobservation and an instantaneous cost according to some typicallyunknown dynamics. The aim is to discover a policy for selecting actionsthat minimizes some measure of a long-term cost, e.g., the expectedcumulative cost. The environment's dynamics and the long-term cost foreach policy are usually unknown but can be estimated.

Today, a common application for neural networks is in the analysis ofvideo streams, i.e. machine vision. Examples include industrialfactories where machine vision is used on the assembly line in themanufacture of goods, autonomous vehicles where machine vision is usedto detect objects in the path of and surrounding the vehicle, etc.

Artificial Neural Network (ANN) have an inherent structure that greatlyrelies on a set of parameters that are attributed to the so-called‘network model’. These parameters are often called ‘weights’ of thenetwork due to their tendency to operate as a scaling factor for otherintermediate values as they propagate along the network. The process fordetermining the values of the weights is called training as describedsupra. Once training is complete, the network settles into a steadystate and can now be used with new (i.e. unknown) data to extractinformation. This stage is referred to as the ‘inference’ stage.

During inference, one can observe the resultant set of parameters,namely the weights, and manipulate them to yield better performance(i.e. representation). Methods for pruning and quantizing weights areknown. These methods, however, are applied only on the trained modelbefore moving to the inference stage. This approach does yield betterexecution performance. It does not, however, fully explore and exploitthe potential of modifying the weights. In addition, existing solutionsapply quantization of weights only after training once the weights ofthe ANN have converged to a satisfactory level.

SUMMARY OF THE INVENTION

The present invention is a neural network (NN) processing engineincorporating processing circuits having compute and local memoryelements adapted to implement artificial neural networks (ANNs). Thegranular nature of the NN processing engine or processor, also referredto as a neurocomputer or neurochip, enables the underpinnings of aneural network to be easily identified and a wide range of neuralnetwork models to be implemented in a very efficient manner. The NNprocessor provides some flexibility in selecting a balance between (1)over-generalizing the architecture regarding the computational aspect,and (2) aggregating computations in dedicated computationally capableunits. The present invention provides an improved balance specific forneural networks and attempts to meet needed capabilities withappropriate capacity. The resulting architecture is thus more efficientand provides substantially higher computational unit density along withmuch lower power consumption per unit.

Several key features of the architecture of the NN processor of thepresent invention include the following: (1) computational units areself-contained and configured to be at full utilization to implementtheir target task; (2) a hierarchical architecture provides homogeneityand self-similarity thereby enabling simpler management and control ofsimilar computational units, aggregated in multiple levels of hierarchy;(3) computational units are designed with minimal overhead as possible,where additional features and capabilities are placed at higher levelsin the hierarchy (i.e. aggregation); (4) on-chip memory provides storagefor content inherently required for basic operation at a particularhierarchy is coupled with the computational resources in an optimalratio; (5) lean control provides just enough control to manage only theoperations required at a particular hierarchical level; and (6) dynamicresource assignment agility can be adjusted as required depending onavailability and capacity.

This, additional, and/or other aspects and/or advantages of theembodiments of the present invention are set forth in the detaileddescription which follows; possibly inferable from the detaileddescription; and/or learnable by practice of the embodiments of thepresent invention.

There is thus provided in accordance with the invention, a neuralnetwork (NN) processing element circuit for use in a NN processor forperforming neural network calculations for an artificial neural network(ANN) having one or more network layers, comprising a multiplieroperative to receive weight and input data and to generate a producttherefrom, an adder operative to receive and sum the product and acurrent context to generate an updated context therefrom, a local memorycoupled to the adder and operative to store the updated context therein,and wherein individual storage locations in the local memory areaccessed in a predefined manner other than randomly.

There is also provided in accordance with the invention, a neuralnetwork (NN) processing element circuit for use in a NN processor forperforming neural network calculations for an artificial neural network(ANN) having one or more network layers, comprising a plurality ofmultipliers operative to multiply received weight and input data togenerate a product therefrom, an accumulator operative to add theproduct with a current context received from either a local memory ormemory located at a higher aggregation level to generate an updatedcontext therefrom, the local memory coupled to the accumulator andoperative to store the updated context therein in sequential fashion, amultiplexer operative to write the updated context to either the localmemory, the memory located at a higher aggregation level, or to afunction located at a higher aggregation level, in accordance with aselect control signal, and wherein individual storage locations in thelocal memory are accessed in a predefined manner other than randomly.

There is further provided in accordance with the invention, a methodimplemented by an integrated circuit (IC), the IC including a neuralnetwork (NN) processing element circuit for use in a NN processor forperforming neural network calculations for an artificial neural network(ANN) having one or more network layers, the method comprisingmultiplying ANN weight and input data to generate a product therefrom,summing the product and a current context to generate an updated contexttherefrom, storing the updated context in a memory local and dedicatedto the processing element circuit, and wherein individual storagelocations in the local memory are accessed in a predefined manner otherthan randomly.

There is also provided in accordance with the invention, a methodimplemented by an integrated circuit (IC), the IC including a neuralnetwork (NN) processing element circuit for use in a NN processor forperforming neural network calculations for an artificial neural network(ANN) having one or more network layers, the method comprising receivinga first operand, a second operand, and a third operand, dividingoperation of the processing element circuit into time slots, performingcomputations involving the first operand, the second operand, and thethird operand to generate an updated data element therefrom, storing thedata element in a memory local and dedicated to the processing elementcircuit, wherein individual storage locations in the local memory areaccessed in a predefined manner other than randomly, and wherein dataelements are time-multiplexed with each location in the memoryrepresenting different data elements from a plurality of data elementsat different times.

BRIEF DESCRIPTION OF THE DRAWINGS

The present invention is explained in further detail in the followingexemplary embodiments and with reference to the figures, where identicalor similar elements may be partly indicated by the same or similarreference numerals, and the features of various exemplary embodimentsbeing combinable. The invention is herein described, by way of exampleonly, with reference to the accompanying drawings, wherein:

FIG. 1 is a block diagram illustrating an example computer processingsystem adapted to implement one or more portions of the presentinvention;

FIG. 2 is a diagram illustrating a first example artificial neuralnetwork;

FIG. 3 is a diagram illustrating an example multi-layer abstraction fora neural network processing system;

FIG. 4 is a high-level block diagram illustrating an example SoC basedNN processing system comprising one or more NN processing cores;

FIG. 5 is a high-level block diagram illustrating an example NNprocessing core in more detail;

FIG. 6 is a block diagram illustrating a first example low-levelprocessing element (PE) in more detail;

FIG. 7A is a block diagram illustrating a second example low-levelprocessing element (PE) in more detail;

FIG. 7B is a block diagram illustrating the quad multiplier of the PE inmore detail;

FIG. 8 is a high-level block diagram illustrating a first examplesubcluster in more detail;

FIG. 9 is a high-level block diagram illustrating a second examplesubcluster in more detail;

FIG. 10 is a high-level block diagram illustrating a first examplecluster in more detail;

FIG. 11 is a high-level block diagram illustrating a second examplecluster in more detail;

FIG. 12 is a high-level block diagram illustrating the inter-clustercrossconnect in more detail;

FIG. 13 is a diagram illustrating a first example memory windowingscheme;

FIG. 14 is a diagram illustrating a second example memory windowingscheme;

FIG. 15 is a diagram illustrating first example memory accessibilitybetween compute and memory elements including window size and computeraccess configurability;

FIG. 16 is a diagram illustrating second example memory accessibilitybetween compute and memory elements;

FIG. 17 is a diagram illustrating an example scatter/gather basedresource windowing technique;

FIG. 18 is a block diagram illustrating an example memory contentionresolution scheme;

FIG. 19 is a high-level block diagram illustrating a first example layercontroller in more detail;

FIG. 20 is a high-level block diagram illustrating the layer controllerinterface to L3 memory and subclusters in more detail;

FIG. 21 is a high-level block diagram illustrating a second examplelayer controller in more detail;

FIG. 22 is a high-level block diagram illustrating an example NNprocessor compiler/SDK;

FIG. 23 is a diagram illustrating the flexible processing granularity ofthe NN processor and related memory versus latency trade-off;

FIG. 24 is a diagram illustrating a first example multi-NN processor SoCsystem of the present invention;

FIG. 25 is a diagram illustrating a second example multi-NN processorSoC system of the present invention;

FIG. 26 is a diagram illustrating a first example multi-NN processor SoCsystem of the present invention;

FIG. 27 is a diagram illustrating a first example multi-NN processor SoCsystem of the present invention;

FIG. 28 is a diagram illustrating an example mapping strategy for thefirst example artificial neural network of FIG. 2;

FIG. 29 is a diagram illustrating a second example artificial neuralnetwork;

FIG. 30 is a diagram illustrating an example multi-NN processor SoCsystem of the ANN of FIG. 29;

FIG. 31 is a diagram illustrating a third example artificial neuralnetwork;

FIG. 32 is a diagram illustrating a first example multi-NN processor SoCsystem of the ANN of FIG. 31; and

FIG. 33 is a diagram illustrating a second example multi-NN processorSoC system of the ANN of FIG. 31.

DETAILED DESCRIPTION

In the following detailed description, numerous specific details are setforth in order to provide a thorough understanding of the invention. Itwill be understood by those skilled in the art, however, that thepresent invention may be practiced without these specific details. Inother instances, well-known methods, procedures, and components have notbeen described in detail so as not to obscure the present invention.

Among those benefits and improvements that have been disclosed, otherobjects and advantages of this invention will become apparent from thefollowing description taken in conjunction with the accompanyingfigures. Detailed embodiments of the present invention are disclosedherein; however, it is to be understood that the disclosed embodimentsare merely illustrative of the invention that may be embodied in variousforms. In addition, each of the examples given in connection with thevarious embodiments of the invention which are intended to beillustrative, and not restrictive.

The subject matter regarded as the invention is particularly pointed outand distinctly claimed in the concluding portion of the specification.The invention, however, both as to organization and method of operation,together with objects, features, and advantages thereof, may best beunderstood by reference to the following detailed description when readwith the accompanying drawings.

The figures constitute a part of this specification and includeillustrative embodiments of the present invention and illustrate variousobjects and features thereof. Further, the figures are not necessarilyto scale, some features may be exaggerated to show details of particularcomponents. In addition, any measurements, specifications and the likeshown in the figures are intended to be illustrative, and notrestrictive. Therefore, specific structural and functional detailsdisclosed herein are not to be interpreted as limiting, but merely as arepresentative basis for teaching one skilled in the art to variouslyemploy the present invention. Further, where considered appropriate,reference numerals may be repeated among the figures to indicatecorresponding or analogous elements.

Because the illustrated embodiments of the present invention may for themost part, be implemented using electronic components and circuits knownto those skilled in the art, details will not be explained in anygreater extent than that considered necessary, for the understanding andappreciation of the underlying concepts of the present invention and inorder not to obfuscate or distract from the teachings of the presentinvention.

Any reference in the specification to a method should be applied mutatismutandis to a system capable of executing the method. Any reference inthe specification to a system should be applied mutatis mutandis to amethod that may be executed by the system.

Throughout the specification and claims, the following terms take themeanings explicitly associated herein, unless the context clearlydictates otherwise. The phrases “in one embodiment,” “in an exampleembodiment,” and “in some embodiments” as used herein do not necessarilyrefer to the same embodiment(s), though it may. Furthermore, the phrases“in another embodiment,” “in an alternative embodiment,” and “in someother embodiments” as used herein do not necessarily refer to adifferent embodiment, although it may. Thus, as described below, variousembodiments of the invention may be readily combined, without departingfrom the scope or spirit of the invention.

In addition, as used herein, the term “or” is an inclusive “or”operator, and is equivalent to the term “and/or,” unless the contextclearly dictates otherwise. The term “based on” is not exclusive andallows for being based on additional factors not described, unless thecontext clearly dictates otherwise. In addition, throughout thespecification, the meaning of “a,” “an,” and “the” include pluralreferences. The meaning of “in” includes “in” and “on.”

As will be appreciated by one skilled in the art, the present inventionmay be embodied as a system, method, computer program product or anycombination thereof. Accordingly, the present invention may take theform of an entirely hardware embodiment, an entirely software embodiment(including firmware, resident software, micro-code, etc.) or anembodiment combining software and hardware aspects that may allgenerally be referred to herein as a “circuit,” “module” or “system.”Furthermore, the present invention may take the form of a computerprogram product embodied in any tangible medium of expression havingcomputer usable program code embodied in the medium.

The invention may be described in the general context ofcomputer-executable instructions, such as program modules, beingexecuted by a computer. Generally, program modules include routines,programs, objects, components, data structures, etc. that performparticular tasks or implement particular abstract data types. Theinvention may also be practiced in distributed computing environmentswhere tasks are performed by remote processing devices that are linkedthrough a communications network. In a distributed computingenvironment, program modules may be located in both local and remotecomputer storage media including memory storage devices.

Any combination of one or more computer usable or computer readablemedium(s) may be utilized. The computer-usable or computer-readablemedium may be, for example but not limited to, an electronic, magnetic,optical, electromagnetic, infrared, or semiconductor system, apparatus,device, or propagation medium. More specific examples (a non-exhaustivelist) of the computer-readable medium would include the following: anelectrical connection having one or more wires, a portable computerdiskette, a hard disk, a random access memory (RAM), a read-only memory(ROM), an erasable programmable read-only memory (EPROM or flashmemory), an optical fiber, a portable compact disc read-only memory(CDROM), an optical storage device, a transmission media such as thosesupporting the Internet or an intranet, or a magnetic storage device.Note that the computer-usable or computer-readable medium could even bepaper or another suitable medium upon which the program is printed, asthe program can be electronically captured, via, for instance, opticalscanning of the paper or other medium, then compiled, interpreted, orotherwise processed in a suitable manner, if necessary, and then storedin a computer memory. In the context of this document, a computer-usableor computer-readable medium may be any medium that can contain or storethe program for use by or in connection with the instruction executionsystem, apparatus, or device.

Computer program code for carrying out operations of the presentinvention may be written in any combination of one or more programminglanguages, including an object-oriented programming language such asJava, Smalltalk, C++, C# or the like, conventional proceduralprogramming languages, such as the “C” programming language, andfunctional programming languages such as Prolog and Lisp, machine code,assembler or any other suitable programming languages. The program codemay execute entirely on the user's computer, partly on the user'scomputer, as a stand-alone software package, partly on the user'scomputer and partly on a remote computer or entirely on the remotecomputer or server. In the latter scenario, the remote computer may beconnected to the user's computer through any type of network using anytype of network protocol, including for example a local area network(LAN) or a wide area network (WAN), or the connection may be made to anexternal computer (for example, through the Internet using an InternetService Provider).

The present invention is described below with reference to flowchartillustrations and/or block diagrams of methods, apparatus (systems) andcomputer program products according to embodiments of the invention. Itwill be understood that each block of the flowchart illustrations and/orblock diagrams, and combinations of blocks in the flowchartillustrations and/or block diagrams, can be implemented or supported bycomputer program instructions. These computer program instructions maybe provided to a processor of a general-purpose computer, specialpurpose computer, or other programmable data processing apparatus toproduce a machine, such that the instructions, which execute via theprocessor of the computer or other programmable data processingapparatus, create means for implementing the functions/acts specified inthe flowchart and/or block diagram block or blocks.

These computer program instructions may also be stored in acomputer-readable medium that can direct a computer or otherprogrammable data processing apparatus to function in a particularmanner, such that the instructions stored in the computer-readablemedium produce an article of manufacture including instruction meanswhich implement the function/act specified in the flowchart and/or blockdiagram block or blocks.

The computer program instructions may also be loaded onto a computer orother programmable data processing apparatus to cause a series ofoperational steps to be performed on the computer or other programmableapparatus to produce a computer implemented process such that theinstructions which execute on the computer or other programmableapparatus provide processes for implementing the functions/actsspecified in the flowchart and/or block diagram block or blocks.

The invention is operational with numerous general purpose or specialpurpose computing system environments or configurations. Examples ofwell-known computing systems, environments, and/or configurations thatmay be suitable for use with the invention include, but are not limitedto, personal computers, server computers, cloud computing, hand-held orlaptop devices, multiprocessor systems, microprocessor, microcontrolleror microcomputer based systems, set top boxes, programmable consumerelectronics, ASIC or FPGA core, DSP core, network PCs, minicomputers,mainframe computers, distributed computing environments that include anyof the above systems or devices, and the like.

In addition, the invention is operational in systems incorporating videoand still cameras, sensors, etc. such as found in automated factories,autonomous vehicles, in mobile devices such as tablets and smartphones,smart meters installed in the power grid and control systems for robotnetworks. In general, any computation device that can host an agent canbe used to implement the present invention.

A block diagram illustrating an example computer processing systemadapted to implement one or more portions of the present invention isshown in FIG. 1. The exemplary computer processing system, generallyreferenced 10, for implementing the invention comprises ageneral-purpose computing device 11. Computing device 11 comprisescentral processing unit (CPU) 12, host/PIC/cache bridge 20 and mainmemory 24.

The CPU 12 comprises one or more general purpose CPU cores 14 andoptionally one or more special purpose cores 16 (e.g., DSP core,floating point, GPU, and neural network optimized core). The one or moregeneral purpose cores execute general purpose opcodes while the specialpurpose cores execute functions specific to their purpose. The CPU 12 iscoupled through the CPU local bus 18 to a host/PCI/cache bridge orchipset 20. A second level (i.e. L2) cache memory (not shown) may becoupled to a cache controller in the chipset. For some processors, theexternal cache may comprise an L1 or first level cache. The bridge orchipset 20 couples to main memory 24 via memory bus 20. The main memorycomprises dynamic random access memory (DRAM) or extended data out (EDO)memory, or other types of memory such as ROM, static RAM, flash, andnon-volatile static random access memory (NVSRAM), bubble memory, etc.

The computing device 11 also comprises various system components coupledto the CPU via system bus 26 (e.g., PCI). The host/PCI/cache bridge orchipset 20 interfaces to the system bus 26, such as peripheral componentinterconnect (PCI) bus. The system bus 26 may comprise any of severaltypes of well-known bus structures using any of a variety of busarchitectures. Example architectures include Industry StandardArchitecture (ISA) bus, Micro Channel Architecture (MCA) bus, EnhancedISA (EISA) bus, Video Electronics Standards Associate (VESA) local busand Peripheral Component Interconnect (PCI) also known as Mezzanine bus.

Various components connected to the system bus include, but are notlimited to, non-volatile memory (e.g., disk based data storage) 28,video/graphics adapter 30 connected to display 32, user input interface(I/F) controller 31 connected to one or more input devices such mouse34, tablet 35, microphone 36, keyboard 38 and modem 40, networkinterface controller 42, peripheral interface controller 52 connected toone or more external peripherals such as printer 54 and speakers 56. Thenetwork interface controller 42 is coupled to one or more devices, suchas data storage 46, remote computer 48 running one or more remoteapplications 50, via a network 44 which may comprise the Internet cloud,a local area network (LAN), wide area network (WAN), storage areanetwork (SAN), etc. A small computer systems interface (SCSI) adapter(not shown) may also be coupled to the system bus. The SCSI adapter cancouple to various SCSI devices such as a CD-ROM drive, tape drive, etc.

The non-volatile memory 28 may include various removable/non-removable,volatile/nonvolatile computer storage media, such as hard disk drivesthat reads from or writes to non-removable, nonvolatile magnetic media,a magnetic disk drive that reads from or writes to a removable,nonvolatile magnetic disk, an optical disk drive that reads from orwrites to a removable, nonvolatile optical disk such as a CD ROM orother optical media. Other removable/non-removable, volatile/nonvolatilecomputer storage media that can be used in the exemplary operatingenvironment include, but are not limited to, magnetic tape cassettes,flash memory cards, digital versatile disks, digital video tape, solidstate RAM, solid state ROM, and the like.

A user may enter commands and information into the computer throughinput devices connected to the user input interface 31. Examples ofinput devices include a keyboard and pointing device, mouse, trackballor touch pad. Other input devices may include a microphone, joystick,game pad, satellite dish, scanner, etc.

The computer 11 may operate in a networked environment via connectionsto one or more remote computers, such as a remote computer 48. Theremote computer may comprise a personal computer (PC), server, router,network PC, peer device or other common network node, and typicallyincludes many or all of the elements described supra. Such networkingenvironments are commonplace in offices, enterprise-wide computernetworks, intranets and the Internet.

When used in a LAN networking environment, the computer 11 is connectedto the LAN 44 via network interface 42. When used in a WAN networkingenvironment, the computer 11 includes a modem 40 or other means forestablishing communications over the WAN, such as the Internet. Themodem 40, which may be internal or external, is connected to the systembus 26 via user input interface 31, or other appropriate mechanism.

The computing system environment, generally referenced 10, is an exampleof a suitable computing environment and is not intended to suggest anylimitation as to the scope of use or functionality of the invention.Neither should the computing environment be interpreted as having anydependency or requirement relating to any one or combination ofcomponents illustrated in the exemplary operating environment.

In one embodiment, the software adapted to implement the system andmethods of the present invention can also reside in the cloud. Cloudcomputing provides computation, software, data access and storageservices that do not require end-user knowledge of the physical locationand configuration of the system that delivers the services. Cloudcomputing encompasses any subscription-based or pay-per-use service andtypically involves provisioning of dynamically scalable and oftenvirtualized resources. Cloud computing providers deliver applicationsvia the internet, which can be accessed from a web browser, while thebusiness software and data are stored on servers at a remote location.

In another embodiment, software adapted to implement the system andmethods of the present invention is adapted to reside on a computerreadable medium. Computer readable media can be any available media thatcan be accessed by the computer and capable of storing for later readingby a computer a computer program implementing the method of thisinvention. Computer readable media includes both volatile andnonvolatile media, removable and non-removable media. By way of example,and not limitation, computer readable media may comprise computerstorage media and communication media. Computer storage media includesvolatile and nonvolatile, removable and non-removable media implementedin any method or technology for storage of information such as computerreadable instructions, data structures, program modules or other data.Computer storage media includes, but is not limited to, RAM, ROM,EEPROM, flash memory or other memory technology, CD-ROM, digitalversatile disks (DVD) or other optical disk storage, magnetic cassettes,magnetic tape, magnetic disk storage or other magnetic storage devices,or any other medium which can be used to store the desired informationand which can be accessed by a computer. Communication media typicallyembodies computer readable instructions, data structures, programmodules or other data such as a magnetic disk within a disk drive unit.The software adapted to implement the system and methods of the presentinvention may also reside, in whole or in part, in the static or dynamicmain memories or in firmware within the processor of the computer system(i.e. within microcontroller, microprocessor or microcomputer internalmemory).

Other digital computer system configurations can also be employed toimplement the system and methods of the present invention, and to theextent that a particular system configuration is capable of implementingthe system and methods of this invention, it is equivalent to therepresentative digital computer system of FIG. 1 and within the spiritand scope of this invention.

Once they are programmed to perform particular functions pursuant toinstructions from program software that implements the system andmethods of this invention, such digital computer systems in effectbecome special purpose computers particular to the method of thisinvention. The techniques necessary for this are well-known to thoseskilled in the art of computer systems.

It is noted that computer programs implementing the system and methodsof this invention will commonly be distributed to users on adistribution medium such as floppy disk, CDROM, DVD, flash memory,portable hard disk drive, etc. From there, they will often be copied toa hard disk or a similar intermediate storage medium. When the programsare to be run, they will be loaded either from their distribution mediumor their intermediate storage medium into the execution memory of thecomputer, configuring the computer to act in accordance with the methodof this invention. All these operations are well-known to those skilledin the art of computer systems.

The flowchart and block diagrams in the figures illustrate thearchitecture, functionality, and operation of possible implementationsof systems, methods and computer program products according to variousembodiments of the present invention. In this regard, each block in theflowchart or block diagrams may represent a module, segment, or portionof code, which comprises one or more executable instructions forimplementing the specified logical function(s). It should also be notedthat, in some alternative implementations, the functions noted in theblock may occur out of the order noted in the figures. For example, twoblocks shown in succession may, in fact, be executed substantiallyconcurrently, or the blocks may sometimes be executed in the reverseorder, depending upon the functionality involved. It will also be notedthat each block of the block diagrams and/or flowchart illustration, andcombinations of blocks in the block diagrams and/or flowchartillustration, can be implemented by special purpose hardware-basedsystems that perform the specified functions or acts, or by combinationsof special purpose hardware and computer instructions.

Neural Network (NN) Processing Core

At a very high-level, an ANN is essentially a function with a largenumber of parameters, mapping between an input space to an output space.Thus, an ANN can be viewed as a sequence of computations. ANNs, however,have a certain internal structure and a set of properties. Consideringthis unique structure, the neural network (NN) processor comprises aplurality of basic computation units doing the same or similarmathematical manipulations, which, when combined together make up theneural network.

The following set of notations is used herein to uniquely describe thenetwork:

ANN∝{X^(<S>), Y^(<T>), M^(<W>)}  (1)

where:

-   -   X^(<S>) represents the input dataset, characterized by a certain        structure S;    -   Y^(<T>) represents the output dataset with a format denoted by        T;    -   M^(<W>) represents the ANN model, which, given a set of        parameters or weights (W) is a function that maps input to        output;

A diagram illustrating an example artificial neural network is shown inFIG. 2. The example ANN, generally referenced 350, comprises fournetwork layers 352, including network layers 1 through 4. Each networklayer comprises a plurality of neurons 354. Inputs X₁ to X₁₄ are inputto network layer 1. Weights 358 are applied to the inputs of each neuronin a network layer. The outputs of one network layer forming the inputto the next network layer until the final outputs 359, outputs 1 through3, are generated.

In one embodiment, the architecture of the present invention comprises amulti-layer architecture (i.e. not referred to ANN layers) thataddresses the computational needs of an artificial neural network to itsfull capacity. The term multi-layer refers to an approach similar tothat of the well-known ISO OSI-layer model for networking whichdescribes the overall solution at varying levels of abstraction.

A diagram illustrating an example multi-layer abstraction for a neuralnetwork processing system is shown in FIG. 3. The equivalent model forneural network processing, generally referenced 410, comprises sixlayers, including: Layer 1 (Physical 412) comprising the physicalprimitives making up the various units; Layer 2 (Unit 414) comprisingthe basic computational unit that underlies the neural network; Layer 3(Interconnect 416) comprising the interconnect fabric that provides thenetwork connectivity; Layer 4 (Management 418) providing network levelflow control, monitoring and diagnostics; Layer 5 (Interface 420)providing the application layer interface and mapping to architectureprimitives; and Layer 6 (Application 422) comprising the neural networkbased application.

A high-level block diagram illustrating an example system on chip (SoC)NN processing system comprising one or more NN processing cores is shownin FIG. 4. The SoC NN processing system, generally referenced 100,comprises at least one NN processor integrated circuit (or core) 102optionally coupled to one or more additional internal or external NNprocessors 104 via one or more suitable chip to chip interfaces, a busfabric 106 adapted to couple the NN processor to various system on chipelements 108, microcontroller unit (MCU) subsystem 118, and one or moreinterfaces 126.

In one embodiment, the SoC 108 includes bootstrap circuit block 110,debug circuit block 112, power circuit block 114, and clock circuitblock 116. The MCU subsystem 118 includes a controller circuit block120, instruction memory 122, and data memory 124. Interfaces 126comprise a pin multiplexer 139, and one or more well-known interfacesincluding camera serial interface (CSI) 128, display serial interface(DSI), Ethernet 132, universal serial bus (USB) 134, inter-integratedcircuit (I²C) interface 136, serial peripheral interface (SPI) 137, andcontroller area network (CAN) interface 138. Note that these interfacesare shown as an example, as any combination of different interfaces maybe implemented.

A high-level block diagram illustrating an example NN processing core inmore detail is shown in FIG. 5. The NN processing engine or core 60comprises several hierarchical computation units. The lowesthierarchical level is the processing element (PE) 76 with its owndedicated internal Layer 1 or L1 memory 78 in which individual neuronsare implemented. A plurality of N PEs 76 along with dedicated Layer 2 orL2 memory 74 make up the next hierarchical level termed a subcluster 70.A plurality of M subclusters 70 along with dedicated Layer 3 or L3memory 72, a plurality of activation function circuits 80, and aplurality of layer controller (LC) circuits 82 make up a cluster 66. Aplurality of L clusters along with dedicated Layer 4 or L4 memory 64 arein the NN processor core 60 which also comprises NN manager circuit 62,and memory interface 68 to off-chip Layer 5 or L5 memory 98. A pluralityof bus interfaces 86 (i.e. chip-to-chip interfaces) couple the NNprocessor to other off-chip NN processor chips for additional networkcapacity. Bus interface 84 (i.e. chip-to-chip interface) couples the NNprocessor to a conventional rule based machine (RBM) co-processor 88comprising a CPU 90, instruction memory 92 and data memory 94. In analternative embodiment, the RBM co-processor is optionally coupled tothe NN device 60 via a suitable interface, e.g., GPUs, I²C, etc.

Note that in an example NN processor embodiment, a PE comprises P=16neurons, a subcluster comprises N=64 PEs, a cluster comprises M=64subclusters, and the NN core comprises L=8 clusters. It is appreciatedthat the NN processor can be implemented having any desired number ofhierarchical levels as well as any number of computation units withineach level and is not limited to the examples described herein which areprovided for illustration purposes only. In addition, any number ofactivation functions 80 and layer controllers 82 may be implemented inthe cluster level or in any other level depending on the design goalsand particular implementation of the NN processor.

In one embodiment, the NN manager 62 is a specialized processor thatcontrols two data pipes: one parallel and one serial along withfunctions to drive the network fabric. This processor carries outspecial purpose operations that are native to the control plane of theneural network. Example operations includes, but are not limited to,Infer, Train, Load weights, and Update weights. Load balancing andresource allocation are handled by an external software tool chain,which includes a set of tools including a compiler, mapper, andallocator, that address these tasks.

In one embodiment, the NN processor includes shared memory for thestorage of weights and dedicated memory elements are for storingcontexts thereby enabling relatively high data processing bandwidth. Inaddition, the NN processor includes data and control planes that arestrictly separate from each other and that provide out of band controlto the computation elements. Moreover, the NN processor includes aconfigurable interconnect between aggregation levels to yield a dynamicand programmable data pipeline.

In another embodiment, the NN processor is capable of implementingmultiple ANNs in parallel, where each ANN has one or more networklayers. The NN processor is adapted to simultaneously process one ormore input data streams associated with the ANNs. Since the architectureof the NN device resembles the structure of an ANN, multiple ANNs can beviewed as a single wide ANN. Note that when deploying multiple ANNs,given enough resources, the mapper in the external tool chain isoperative to map available resources while the NN manager governs eventtriggers. In this case, due to the enormous parallelism of the device,each set of resources grouped within a ‘layer’ of the ANN is independentfrom each other.

In addition, the computation elements of the NN processor are operativeto function at any desired granularity of a subset of the input datastream thereby trading off memory element usage versus latency, asdescribed in more detail infra.

The NN processor of the present invention uses several design principlesin its implementation including: (1) just in time usage of systemresources; (2) dynamic allocation of system resources per need; (3)leveraging both the time-domain and the space-domain to optimizeutilization and efficiency; and (4) balanced load over available systemresources.

Note that the present invention is well suited to implement ANNs.Typically, ANNs are implemented in three stages: modeling, training, andinference, all three of which are addressed to some extent by the NNprocessor of the present invention.

Regarding modeling, the NN processor is capable of altering the modelrepresentation statically and dynamically thus reflecting its flexiblenature. The ‘processor’ notation is used as opposed to an ‘accelerator’since the latter is typically adapted a priori to exercise a predefinedset of operations. Regarding training, the NN processor supportson-the-fly and complementary training operations that allowsimplementation of the training procedure. This includes: (1) runningback and forth through the network (i.e. backpropagation); (2)dynamically applying dropout; and (3) on-the-fly evaluation of layerperformance and ill behavior detection. During the inference mode, theANN is executed optimally and efficiently and is applied to new inputs.

The NN processor of the present invention combines several features thatcombine together to provide extremely high computation rate, small chipfootprint, low power consumption, scalability, programmability, andflexibility to handle many types of neural networks.

A first feature comprises the compute fabric (or compute capability)provided by the computation units that are organized into variousaggregation levels or hierarchical levels, such as PEs, subclusters,clusters, NN cores as described in the example system disclosed herein.The compute fabric comprises the basic compute elements that areconfigured to address the special nature of the computational needs ofANNs. Several features of the compute fabric include: (1) a lean circuitarchitecture thereby allowing a relatively large number of physicalentities to be implemented; (2) a large number of multiply andaccumulate operations at once, where additions are performed asaccumulations; (3) flexibility of number representation, includinginteger and floating point as well as different bit widths; (4)quad-multiplier support allowing for higher resolution computations; and(5) N-way ALU support to provide the capability of optimizing memorybandwidth, i.e. instead of performing a single operation per cycle suchas y←y+w*x, a more complex operation such as y←y+w₁*x₁+w₂*x₂ can beimplemented which reflects a trade-off between an increase in siliconcomplexity and reduced memory access required.

A second feature is the control plane and the strict separation of thecontrol fabric from the data fabric which enables aggregation of controlas well as very ‘lean’ or ‘slim’ control of the entire data fabric (i.e.data plane). The control plane is separate from the data plane and thusit can be aggregated in the sense that a large number of compute unitsare controlled using relatively few control lines, e.g., by a singlecontrol line in some cases. For example, considering the multiplycircuits in the PEs, a single control signal initiates the multiplyoperation in thousands of PEs at the same time. Further, theprogrammability of the control plane is separate from theprogrammability of the data plane. The massive parallelism of the datafabric of the NN core is matched by the lean structure of the controlplane.

This is in contrast to the typical prior art approach of in-band controlwhere control signals are applied in close proximity to the data whichrequire the replication of the control signals by the number of computeelements. Furthermore, out-of-band control is in contrast to traditionalmicrocontroller based techniques as it is not a Von-Neuman machine basedtechnique.

Another advantage of the separation of control and data fabric is thatthe control remains programmable. The non-rigid implementation of thecontrol fabric and the general nature of the computation units (i.e.PEs, subclusters, clusters, etc.) allows the NN core to handle numeroustypes of ANNs, such as convolutional NNs (CNNs), recurrent NNs (RNNs),deep NNs (DNNs), MLPs, etc., as well as more intricate implementationsof the above and subtle combinations and properties of each, e.g.,stride, padding, etc. implemented in convolutional modes.

A third feature is the structure of the memory fabric including memorywindowing. In addition to the localization and hierarchical structure ofthe memory, high bandwidth access to the memory is provided in parallelto a large number of computation units. This is achieved by narrowingaccess for a particular computation unit to only a small portion of thememory. Thus, full random access to the entire memory is not provided.Rather, access to only a relatively small window of memory is provided.This allows simultaneous access across thousands of computation units,thus representing a tradeoff between bandwidth and random accessibility.Since a single compute unit memory access pattern is structured andwell-defined by the ANN and does not require full random access to theentire memory, access can be ‘windowed’ to only those few memory blocksrequired for that particular compute unit. Thus, extremely high memorybandwidth is achieved whereby thousands of compute units can accessmemory simultaneously in parallel with the tradeoff being access only tomemory that is ‘local’ to the compute unit.

In one embodiment, the architecture of the NN processor comprises acontrol plane and a data plane (or control fabric and data fabric). Thecontrol plane is responsible for configuring and controlling all thedata computation units in the NN processor. It comprises a dataflowmachine or processor incorporating, in one embodiment, microcodetailored for neural network operations. In the example NN processordescribed herein, the control plane governs the cluster entities 66which functions as an aggregator for the next layer of aggregation, i.e.the subcluster 70. The subcluster, in turn, comprises the most basicunits, namely the processing elements (PEs) 76 which are composed of amultiply and accumulate (MAC) circuit and local memory. It is the PEhierarchical level that contains a set of neuron entities found in atypical neural network.

An important aspect of implementing an ANN in the NN processor is thecontrol and interconnect of all the compute elements. The very largenumber of compute elements in an ANN is leveraged by the presentinvention. One feature of the device control fabric is that it isrelatively very lean since it is shared among a large set of computeresources. In one embodiment, the NN processor features (1) strictseparation between data and control, where the control signaling isperformed out of band and does not include any data driven memoryaccess; (2) dynamic mapping between control and attached computeresources; and (3) flexibility and programmability of the control fabric(i.e. at compile time). In addition, the NN processor includes layercontrollers incorporating microcode machines that allow fullaccessibility to the control signaling of the computational elements,memory etc.

Note that data driven memory access denotes access that involvesobservation of the data that flows through the data pipeline. The NNprocessor does not require this. Note that data driven memory access iscommon in rule based machines since the nature of the rules is datadependent and thus control must be intertwined with data. For example,consider the statement: if (x>some_value) then do A. This implies theneed to observe every input ‘x’. In contrast, consider a machine thatcompares many inputs with a threshold. The microcode in this case onlyneeds to trigger an operation that applies a massive set of comparators.Such an approach, however, cannot be taken in an RBM because it impliesa huge number of operations that must be hardwired which negates thepossibility of programing the machine.

The NN processor, in contrast, operates on data using a very limited setof operations. The nature of the processing flow does not involve thevalue of the data. Thus, it is possible aggregate control and drive anenormous set of compute elements with relatively few control signals.For example, in the NN device, a control bus of 64 control signals isneeded to control thousands of compute units.

In one embodiment the NN processor is implemented such thatfunctionality is provided at several points of aggregation where it isneeded, as described in more detail infra. In addition, the NN processoris configured to be substantially balanced in terms of compute andmemory resources to ensure the system achieves maximal utilization.

In the event that the capacity of the NN processor is insufficient for aparticular neural network, bus interfaces 86 provide for interconnectingadditional NN processors 96 to extend beyond the limitations of a singleprocessor.

In one embodiment, an RBM coprocessor subsystem 88 is configured tosupport one or more primitives that are not supported by the NNprocessor. In addition, the coprocessor functions to exchange tasksextracted from the ANN and assigned to the RBM.

The NN processor essentially operates as a dataflow machine meaning thatthe calculations are executed based solely upon the availability ofdata. The data flow is divided between layers, which are analogous tothe layers in the ANN. The computation units inside a layer actsynchronously, starting when data is ready at the layer's input andending when they need new data and/or need to pass results to the nextlayer, at which point the layer's state machine synchronizes with theprevious and/or next layer's state machine.

As an example, an MLP network with two dense layers can be mapped as (1)one layer which receives input from outside the core, (2) two layerswhich represent the neural network layers, and (3) one layer which sendsthe result outside the core.

In one embodiment, the input layer waits until it receives all theinputs (e.g., 784 inputs for the well-known MNIST data set), and thensignals layer 1 that its input is ready. Layer 1 then performs all therequired multiply and accumulate (MAC) operations, the activationfunction, and finally signals to layer 2, which in turn repeats the samesteps. When layer 2 is finished, it signals to the output layer to sendthe results outside the NN core.

In another embodiment, considering the same network, the NN core startsthe MACs in layer 1 on a smaller portion of input data, thus reducingthe buffering required between the input layer and layer 1, at theexpense of complexity of the state machine in layer 1 and possibly lossof compute efficiency during signaling.

Inside the clusters 66 in the NN core, data is passed through shared L3memory 72, while the signaling is performed through a dedicatedinterconnect 374 (FIG. 15), described in more detail infra. In oneembodiment, the AXI4-Stream protocol is used between clusters, whichhandles both data and control planes. To prevent stalls, theinterconnect between the layers provides a dual buffer mechanism, sothat one layer writes its output to one buffer as the second layer readsthe previous output as its input from the second buffer.

In one embodiment, the use of the dataflow architecture together with arelatively limited set of basic operations in neural networks enables asignificant reduction in the requirements of control distribution.

Firstly, much of the information regarding the computation beingperformed is statically known once the network model is defined and cantherefore be loaded via a narrowband interface a priori, thus reducingthe number of control lines required during computation. The result isthat the code for the ‘kernels’ which implement layers is dividedbetween quasi-static configuration that are constant per network modeland dynamic instructions which change throughout the computation.

Secondly, each dynamic ‘instruction’ actually comprises multipleinstructions instructing all the compute elements in a layer what to doin each cycle. As each compute element has relatively simplefunctionality, the basic instructions themselves are relatively simple.Repetitions (i.e. loops) and jump instructions are provided out of band,to avoid wasting cycles.

Thirdly, the static order of computations combined with an appropriatearrangement of parameters in memory enables sequential access to memory.Therefore, only address increment instructions to access memory arerequired rather than full addressing.

Fourthly, since the microcode is very compact, it can reside in on-chipSRAM without the need for prefetch, branch prediction, etc.

Fifthly, although a layer comprises many processing elements (PEs), onlyone central state machine is needed to control the steps of thecomputation for the entire layer along with smaller slave state machineswhich store only a sub-state, with each of them controlling multiplePEs. In one embodiment, a global enable bit starts execution of all thestate machines, and a global synchronous reset signal returns them to aninitial state. Note that reset has no effect on the configuration memoryand the data memory as the control plane ensures that no invalid data isused.

Note that the term ‘model’ is used to describe a quasi-staticconfiguration which defines the dynamic behavior of all the competeunits in the NN core. A model is typically analogous to a ANN model, butthere may be other types of models, such as a model loaded for debugpurposes or for loading weights into memory.

The configuration space is exposed in a memory-like interface, wheremodules are addressed using a hierarchical address space. Weightsloading is normally performed before the configuration of the model andis achieved by configuring control signaling which copies the weightsinto the relevant memory blocks and sets the enable bit. The inferencemodel is then loaded while the cluster is disabled, the control is resetand finally the cluster is enabled.

Memory Hierarchy

In one embodiment, the memory fabric of the NN processor is designed toaddress the inherent nature of ANNs. Thus, the memory is structured in ahierarchical manner in order to address the needs of the various memoryconsumers. These consumers include: (1) inter-layer data (i.e. crosslayer input/output); (2) intra-layer information (i.e. contexts orintermediate results); and (3) weights. The various memory layers (e.g.,five in the example embodiment disclosed herein), go from smaller,efficient, more localized memory to larger, less efficient, globalmemory.

In one embodiment, the memory fabric is organized and constructedutilizing the following: (1) localization of memory where computingelements require access to local data which permits accessibility of anygiven computing element to a predefined and limited memory entity; (2)structured organization whereby memory content is organized a priori ina given consistent matter; (3) limited recall nature (i.e. read once)where most of the data is volatile by nature and once processed, isfully consumed with limited or no need for further access to it; and (4)pipelined operation there the output data of one compute element servesas the input data to another compute element.

As described supra, each hierarchical level contains its own localmemory. PEs comprise L1 memory, subclusters comprise L2 memory, clusterscomprise L3 memory, NN cores comprise L4 memory, and L5 memory islocated externally off-SoC. An example memory hierarchy is presentedbelow in Table 1.

TABLE 1 Memory Hierarchy Bandwidth Usage Memory Size [Bytes/ Input LevelLocation [Bytes] Transaction] Contexts Weights Data L1 PE Baseline (B)L*M*N*2 X L2 Subcluster B*512 L*M*16 X X L3 Cluster B*1024*128 L*128 X XL4 NN Core B*512*128 128 X X L5 External B*1024*2048 0.5 (X) (X) to SoC

Where N represents the number of processing elements in a subcluster, Mis the number of subclusters in a cluster, and L is the number ofclusters in the NN processor device. Note that the size indicated foreach memory level L1 through L5 are for illustration purposes only. Itis appreciated that any desired memory size for the various memorylayers may be implemented without departing from the scope of theinvention.

Note that the lower memory layers, e.g., L1 in the PE, are smaller sizedbut carry the larger bandwidths. The upper memory layers, e.g., L4 inthe NN core, are much larger sized by carry far less traffic.

In accordance with the invention, as much memory as possible is kept asclose as possible to where it is needed while utilizing the localizednature of memory usage in ANNs to avoid providing full mesh accessbetween the entire memory and the compute elements. To overcome therestrictions imposed by the above strategy, the allocation of memory toconsumers is done in a ‘gradual’ way, such that each level of memoryhaving a specific role is complemented by a higher level as it requiresmore resources, where the higher level memory is used for ‘resource loadbalancing’ between multiple layers in the ANN which have differentrequirements.

Note that in one embodiment this ‘spillover’ is a quasi-static feature,as the resource requirements are already known once the model isselected, and thus does not require complex arbitration. This featureallows the static allocation of a significantly lower amount of memoryresources in each layer since they are allocated according to thenominal case rather than the worst case.

In addition, the ‘gradual’ allocation of memory also features a slidingwindow mechanism, described briefly supra, which is used in L3 memoryand described in more detail infra.

Processing Element (PE)

In one embodiment, the basic compute unit is the processing element(PE). A block diagram illustrating an example low-level processingelement (PE) in more detail is shown in FIG. 6. The PE, generallyreferenced 140, comprises one or more multipliers 142 controlled bymultiply trigger 177, an adder 144 controlled by adder trigger 171, L1memory 150 comprising a plurality of registers 152, destinationmultiplexer 146 controlled by destination control 175, sourcemultiplexer 148 controlled by source control 173, write multiplexer 154controlled by output shuffle control 178, and read multiplexer 156controlled by input shuffle control 179.

Input (x) data 161 from input memory 158 and weights (w) 163 from weightmemory 160 are provided to the multiplier(s) 142 in accordance with aninput control and weight control, respectively.

The most basic mathematical operation of a neuron in a neural network isdefined by the following:

y _(j)=σ(Σ_(i=0) ^(N−1) w _(i,j) ·x _(i))   (2)

Where:

-   -   x(i) denotes the input dataset, organized into a 1D vector;    -   w(i,j) denotes the weight representing i^(th) input contribution        to output j;    -   σ denotes the activation function, typically a nonlinear scalar        function;

The basic compute unit is a PE and comprises a multiply/accumulateentity that reflects the intrinsic operation of a neuron. Theintermediate result or outcome is stored in L1 memory 150 which is localto the PE. The L1 memory has a certain depth and width, e.g., number ofneurons P=16, each of which is 16 bits wide, in the example describedherein. It is appreciated that L1 memory having any desired depth andwidth may be used. The depth P of L1 memory reflects the number ofsimultaneous ‘neurons’ or ‘contexts’ a PE can handle. Note that morethan P neurons (i.e. contexts) can be handled by storing intermediateresults for additional neurons in L2/L3 memory. Latency is impacted inthat additional time is required to process the additional neurons.Providing P neurons leverages both the spatial domain by limiting thecomputational construct to the bare minimum, while also leveraging thetime domain by storing multiple contexts.

The capability of handling internal context provides for a number ofcapabilities such as: (1) the ability to assign multiple logical neuronsto a single physical neuron (each context stores the output of oneneuron); (2) storing multiple intermediate results for the same inputresulting in simultaneous operations, and hypothesis testing fordifferent versions of weights (e.g., backpropagation results, correctionvalues based on gradients, etc.); (3) multithreaded inference of thesame inputs for the purpose of applying common methodology of a networkcommittee and a majority vote extraction; (4) running multiple networksif resources are available; and (5) load balancing based on overallnetwork capacity as governed by an NN manager.

In operation, Equation 2 above reflecting neuron functionality is spreadover multiple time instances and implemented as provided below inListing 1. Note that this is an example implementation only as othersequences may be used by loading different microcode to the layercontrollers (LCs) 642 (FIG. 20).

Listing 1: Neuron functionality @ time t = 0: Set default value based onsubcluster control signal as follows: Ctrl = load_zero: y ← 0 Ctrl =load_bias: y ← L2/L3 [@bias_address] Ctrl = load_same: y ← L1[@same_address_index] Ctrl = load_cont: y ← L2 [@next_address_index]Ctrl = load_other: y ← L3 [@previous_layer_neuron_index] @ t = 1...P−1:Apply calculation according to configured representation, based onsubcluster ctrl. Target is stored in place unless otherwise indicated bycontrol signals. y ← y + w * x ‘*’ is implemented as a multiplier withcontrol signals for representation type ‘+’ is implemented as an adderwith control signals for representation type Update weight according tothe control scheme: w ← (ctrl = weight_update) & read_next (base,offset) Update input according to the control scheme: x ← (ctrl =input_update) & read_next (base, offset) @ t = P: Apply activationfunction unless bypassed; activation type determined through controlDestination is pre-configured and auto-determined by activation z ←(ctrl ≅ bypass_activation) & activation_func ( y, type )

With reference to FIG. 6, the PE comprises separately controlledcounting elements for the weights (w) and inputs (x) as well as separatecontrol over the representation format for the adder and multiplier. Italso comprises separately controlled ingress/egress L1 entry index,allowing the order of calculations to be manipulated. The intermediateresults of the accumulation function are stored locally in the L1 memoryregisters 152. In addition, pre-processing during initialization enablesL1 memory to be pre-loaded with default values (e.g. prior intermediateresults, bias values, etc.). The PE also includes intermediate memoryaggregation control, i.e. allocation step size. In addition, activationfunctions are aggregated to minimize area overhead and not implementedat the PE or subcluster level but rather at the cluster level. The PEalso supports activation bypass to permit concatenation.

Pre-synthesis configurability allows for: (1) N-way multiply andaccumulate (i.e. Y=Y+A₁*B₁+ . . . +A_(N)*B_(N)); (2) representationformat span (e.g., support for k₀ . . . k_(N) bits per entry with m-bitmantissa and e-bit exponent, where k=m−e); and (3) selection of localstorage depth P.

In operation, the data flow within the PE is fairly flexible. The output151 of the adder 144 can be steered via destination mux 146 usingdestination control 175 to either (1) the activation function via path162; (2) to L2 or L3 memory via path 164; or (3) to the source mux 148via path 166. The source mux 148 selects via source control 173 either(1) the output from the adder; or (2) an intermediate result from L2 orL3 memory 168. The write mux selects via output shuffle select 178 oneof the neuron registers 152 to write the output of the source mux to viaone of P paths 172. The data written to the L1 memory typicallycomprises intermediate results generated as a result of the multiply andaccumulate operations performed over many cycles.

Data is read out of the L1 memory via one of P paths 174 connecting theneuron registers to the read mux 156 and selected via input shufflecontrol select 179. The output 176 of the read mux forms one of the twoinputs to the adder 144. The other input to the adder being the outputof the multiplier 142. Note that in the event multiple multipliers 142are implemented, a pre-adder (not shown) functions to add the outputs ofthe multipliers to generate a single sum that is then input to the adder144.

A block diagram illustrating a second example low-level processingelement (PE) in more detail is shown in FIG. 7A. As described supra, thePE is the most basic compute element of the NN processor. The neurons ofthe ANN are implemented in the PE, essentially in the L1 memory. Theprocessing element, generally referenced 450, comprises an input datarepresentation circuit 452, multiplier circuit 454, representationtransformation/rounding circuit 456, accumulator (i.e. adder) 458, L1memory 460, negate circuit 472, and multiplexer 474.

In operation, input data (X) 468 and weights (W) 470 are input from L3memory to the input data representation circuit 452. This circuit isoperative to transform the representation of the input data and/orweights from integer to floating point (FP) format and vice versa inaccordance with an INT/FP signal 462 which is also input to themultiplier. The resulting X 504 and W 506 are input to the multiplier454. Note that either of the two PE embodiments shown in FIGS. 6 and 7Amay be used in the NN device of the present invention.

In one embodiment, the multiplier comprises several multipliers thatoperate in parallel. The multiplier is capable of multiplying bothinteger and floating point numbers. The number of significant bits forthe input data and weights can also vary as set by the control inputs464, 466, respectively. The product output of the multiplier 486 isinput to the representation transformation/rounding circuit 456. FPaccumulator and FP input control inputs 508, 510, respectively, signalcircuit 456 whether the product is integer or FP format. In addition,the circuit 456 functions to perform rounding of the product beforeinput to the accumulator.

The output 488 of circuit 456 is input to the accumulator (adder) 458.The second input to the accumulator 496 comprises either a context (i.e.intermediate result) 490 from L2 or L3 memory or the output of local L1memory 460. Multiplexer 474 selects between the two in accordance withSEL 476. The output 494 is input to a negate circuit 472 where, inaccordance with a Negate control 478, the output 496 is negated beforebeing input to the accumulator.

Additional configuration controls to the accumulator include anaccumulator shift signal (accumulator_shift) 498, accumulator enable(accum_en) 500, and FP accumulator 502. The output 484 of theaccumulator is written to the L1 memory. The L1 memory also includes L1output select 480 and zero skip 482. Intermediate results (i.e.contexts) output from the L1 memory are either input to the accumulatorvia path 493 or written to L2 or L3 memory via path 492. In oneembodiment, accumulated (i.e. intermediate) results are written to andread from L1 memory sequentially, i.e. there is no random access to theneuron registers in L1 memory. Note that L1 memory may be accessed usingany suitable predefined pattern other than randomly, e.g., sequential(one by one), skip one, skip two, etc. This greatly simplifies theaddressing required to access the neuron registers. In addition, accessto and from L2 and L3 memory layers is provided in the event not enoughlocal L1 memory is available for a particular ANN. In this case,intermediate results are stored in higher memory layers to accommodatethe particular ANN. The tradeoff, however, is increased latency inaccessing the higher memory layers.

In an alternative embodiment, a higher precision multiplication (e.g.,16-bit) is performed by combining four low precision (e.g., 8-bit)multipliers to generate a high (or double) precision (e.g., 16-bit)product. A block diagram illustrating the quad multiplier of the PE inmore detail is shown in FIG. 7B. The quad multiplier, generallyreferenced 870, comprises four lower precision (e.g., 8-bit) multipliers872, Q₀, Q₁, Q₂, and Q₃. The input to the quad multiplier is a doubleprecision input X made up to two low precision (e.g. 8-bit) values,namely X_(L) 873 and X_(H) 871, and a double precision weight W alsocomprising two low precision (e.g., 8-bit) values, namely W_(L) 880 andX_(H) 882.

In operation, each basic unit Q_(i) receives a low precision (e.g.,8-bit) W and X value and based thereon, the quad multiplier circuitgenerates the result Y←Y+W*X. Considering double precision X and Wvalues, we denote the upper and lower parts of weights, input data andoutput as W_(H) 882, X_(H) 871, Y_(H) 876 and W_(L) 880, X_(L) 873,Y_(L) 875, respectively. Three carries C₀ 874, C₁ 878, and C₂ 879 aregenerated as well.

Expanding Y←Y+W*X into

(Y _(H)<<16+Y _(L))←(W _(H)<<8+W _(L))*(X _(H)<<8+X _(L))   (3)

yields the following

Y _(L) ←W _(L) *X _(L)+[(W _(L) *X _(H) +W _(H) *X _(L))<<8]_(L) +C ₀<<9  (4)

and

Y _(H) ←W _(H) *X _(H)+[(W _(L) *X _(H) +W _(H) *X _(L))<<8]_(H+) C₁<<9+C ₂<<9   (5)

Note that each output Y_(L) and Y_(H) represents a 16-bit number toyield a 32-bit multiplication product Y. It is appreciated that resultsof greater precision can be obtained using additional multipliers andsuitable combination of input, weight and carry components.

Subcluster

A high-level block diagram illustrating a first example subcluster inmore detail is shown in FIG. 8. The subcluster, generally referenced180, comprises a plurality of N PEs 182, each individual PE 182including local L1 memory 184, interconnect fabric 186, dedicated localL2 memory 188 portioned into a plurality of allocated memory blocks 190,configuration and decode block 192, and control/data signals 181. Theconfiguration/decode circuit 192 receives instructions from an externalcontrol bus 194. Each subcluster 180 also communicates with input/outputalignment circuit 196 and activation circuit 198 which in the exampleembodiment presented herein are located in the cluster hierarchy level,as described in more detail infra.

In one embodiment, the function of the subcluster is to aggregate aplurality of N PEs, e.g., N=64. All PEs in a subcluster belong to thesame layer of a neural network which greatly simplifies the controllogic required. For example, apart from a static configuration a priori,control of cycle-by-cycle operation is not needed.

In addition, the subcluster encapsulates the next level of memoryhierarchy, i.e. the L2 memory layer that stores interlayer andintermediate results. In one embodiment, it also includes the activationfunction circuits (i.e. represented by σ in Equation 2 supra). Forefficiency, however, the example NN core moves the activation functionto the cluster level. The activation function, regardless of itslocation receives the outputs of the neurons and is triggered once per Nmultiply and accumulate operations. Note that the number and location ofthe activation function circuits are selected to reflect optimalutilization of hardware.

Several features of the subcluster include: (1) a distributed controlscheme to manage memory access; (2) dynamic allocation of L2 memory forweights and intermediate results; (3) inherent intermediate resultsshuffling support to seamlessly augment L1 memory; (4) layer-centricinformation and diagnostics storage; (5) layer-centric pre-processing;(6) layer-centric post-processing; and (7) in-layer split support (e.g.,for quantization segmentation).

A high-level block diagram illustrating a second example subcluster inmore detail is shown in FIG. 9. While FIG. 8 reflects a mostly logicalview of the subcluster, FIG. 8 reflects a more physical view. Thesubcluster, generally referenced 200, comprises dedicated local L2memory 210, a plurality of N PEs 212, each with its own L1 memory 214and receiving enable EN 211, PE control signal 213, and PE configurationsignal 215, input interconnect 206, output interconnect 208, subclusterconfiguration 202 which receives instructions from the subclustercontrol bus 230 and outputs L2_cbus 236, and subcluster decoder 204which receives layer control 232 and group control 234 and outputsaddress ADDR 238, enable EN 240, and select SEL 242.

In operation, input data 216 and weights 218 are provided from the L3memory at the cluster level to the input interconnect 206 in accordancewith control signal 201. The input interconnect feed input data 244 andweights 246 to the PEs 212. A zero_skip signal 217 notifies the PEs thateither the input data or weights have zero values and thus a multiplyand add operation are not needed. Note that weights 220 may also comefrom local L2 memory 210, which receive address ADDR 205, enable EN 207,and control L2_cbus 209.

Once the neurons in the PEs have accumulated the required calculationsfor a particular layer, the contents of the neurons, now representingintermediate results 248, are read out and output to the outputinterconnect 208 via control signal 203. Intermediate results can thenbe written to local L2 memory via path 226 or written to L3 memory viapath 221, multiplexer 222, and path 228. In addition, intermediateresults 224 can be read from L2 memory and either transferred to L3memory via multiplexer 222 or to the output interconnect which thenforwards it to the PEs via path 249.

Thus, each subcluster comprises flexible and programmable pathways forfeeding input data and weights to the neurons in the PEs as well assteering intermediate results from the neurons to and from either L2 orL3 memory.

In one embodiment, a subcluster is dedicated to the execution of asingle ANN layer or a portion of it. Its function is to receive externalinputs from L3 memory, perform multiply and adds with weights fromeither local L2 or external L3 memory, store intermediate results (alsoreferred to as ‘contexts’) in PE L1 memory (or in local L2 memory whenL1 memory is not sufficient), and finally send the results to theexternal activation function for normalization and activation.

The subcluster decoder 204 functions to combine static input from thesubcluster configuration 202 with dynamic input, both the common layercontrol and the timing group control. The state it stored includescounters which hold the following addressing: (1) weights read/writeaddress; (2) contexts read address; (3) contexts write address; (4)activation source address (which PEs output for reading).

The input interconnect is operative to (1) selects between externalweights (i.e. L3 memory) or local weights (i.e. from L2 memory); (2)select the width of the weights memory, i.e. the number of weightsselected and the depth of the memory where the maximum width allows allPEs to receive a different weight from L2 memory, or from L3 externalmemory; (3) select the weights to pass to the PEs from the selectedweights source (using the MSBs of the address); select the width of theinput bus; and (4) select the inputs to pass to the PEs from theselected input source (using the MSBs of the address).

Note that the L2 memory 210 is used to store both weights and contextsin the same block. The weights addresses start from zero and countupwards while the contexts addresses start from the end of the memory.It is the responsibility of the control plane to prevent overflows.

Cluster

A high-level block diagram illustrating a first example cluster in moredetail is shown in FIG. 10. The cluster, generally referenced 250,comprises a plurality of M subclusters, each subcluster 266 having itsown L2 memory 268, dedicated local L3 memory 262 portioned into aplurality of allocated memory blocks 264, memory management unit (MMU)260 adapted to interface L3 memory to the subclusters, management andcontrol block 252 including control synchronizer 254 and a plurality oflayers control circuits 256, a plurality of input aligners 274, and aplurality of activation function circuits 276. Input/output (I/O) ports270 interface each cluster to an inter-cluster cross connect switch 272.

In one embodiment, the cluster is the next level of aggregationtypically representing more than one neural network layer. It containsboth the subclusters which contain the PE basic computational entitiesas well as the interconnect fabric amongst subclusters. This providesthe NN core with the flexibility to represent different neural networkmodels by controlling the connectivity between subclusters. The L3memory 262 functions to store interlayer results in one or moreallocated memory blocks 264.

Several features of the cluster include: (1) a distributed controlscheme to manage memory access; (2) flexible configurable routing matrixto support representation of the total M subclusters into multiplelayers; (3) dynamic allocation of L3 memory for weights and intermediateresults (relatively infrequent); and (4) interlayer control to allowdata flow throttling and load balancing.

Additional features include: (1) weight/input data balancing; (2) preand post-processing blocks; (3) dynamic bus width and memory bit cell;(4) input data and weights interchangeability in the MMU; (5) thecapability to provide event-driven behavior and pipelining; (6) controlis decoupled from the data plane; (7) optional zero pipeline capability;and (8) balanced capability of runtime configuration modification.

A high-level block diagram illustrating a second example cluster in moredetail is shown in FIG. 11. The cluster, generally referenced 280,comprises a cluster interconnect circuit 282, input buffers 284, outputbuffers 292, plurality of M subclusters 306, subcluster interconnect304, a plurality of activation function/pooling circuits 300, aplurality of input aligner circuits 302, and L3 memory 296 including aplurality of allocated memory blocks 298.

Input data and weights 286 are stored in the input buffers 284. From theinput buffers the input data and weights 288 are input to the clusterinterconnect 282. Input data 305 and weights 307 can also be written toand read from L3 memory 296. Input data 281 from the clusterinterconnect is input to the aligner circuit 302 before being input tothe subcluster interconnect 304. Input data 285 is fed to thesubclusters 306 from the subcluster interconnect while output 283 fromthe subclusters is sent to the subcluster interconnect. The output 309is input to the activation functions/pooling circuits 300 where theresulting output 308 is input to the cluster interconnect 282. Outputdata 290 is written to the output buffers 292. Data output 294 is thensent to other clusters or off-chip.

In one embodiment, the NN core supports multiple neural networks inparallel. Each cluster is operative to expose a control interface (e.g.,clock, reset, enable, etc.), a configuration interface (memory like) anddata interfaces (e.g., Advanced Extensible Interface (AXI)). Eachcluster is adapted to implement one or more ANN layers, possibly frommore than one ANN. The AXI interconnect exposes a control interface, andis used to connect the clusters, the DMA engine of an ARM controller inthe NN core, and external ports. The ARM exposes an AXI interfacethrough a DMA engine, control and configuration interfaces to theclusters and the interconnect, and external standard interfaces.

In one embodiment, clusters comprise: (1) configuration circuit; (2)memory management unit (MMU); (3) control interconnect; (4) triggerinterconnect; (5) multiple subclusters; (6) multiple layer controllers(LCs); (7) multiple special purpose units; (8) multiple input units; (9)multiple output units; and (10) multiple memory blocks (i.e. L3 memory).

In one embodiment, the cluster supports multiple ANN layers in parallel,possibly from multiple ANNs. Note that a network layer can beimplemented as a layer controller (LC) with one or more subclustersconnected through the control interconnect, or one of the special units(special purpose, input or output) which contains the control within.Layers communicate data through the allocated memory blocks 298 in L3memory 296, using signaling for flow control over the triggerinterconnect, all defined by the configuration. The allocated memoryblocks are also used as weight memory for the subclusters. All thecontrol signals from the various layers to the L3 memory are translatedby the MMU 260 from virtual to physical addresses using theconfiguration.

The MMU uses a sliding overlapping window mechanism between twocommunicating port groups, such as the read ports of the L3 memory andthe input ports to the subcluster. Each subcluster can choose its inputfrom a group of memory ports around its relative place in the list ofsubclusters. The window mechanism is described more detail infra.

In order to be able to utilize the pipeline in the NN core efficiently,the allocation of subclusters for each ANN layer is preferablyproportional to the number of computations required in the ANN layer perfeed. The allocation is determined by the control interconnect, whichmaps the subclusters to the LCs. The mapping is performed in two levels:(1) each subcluster is assigned to an LC through a sliding overlappingwindow mechanism (i.e. similar to that used in the MMU); and (2) thesubcluster is assigned to a timing group inside the ANN layer. Thetiming groups spreads over time the actions requiring common resources,such as the write port to L3 used after activation. An ANN layer maycomprise one or more timing groups, each containing one or moresubclusters. The controls, which are common among all timing groups, arenot passed through the second selection level, reducing multiplexingcomplexity of the circuit.

In one embodiment, the signaling mechanism between ANN layers is basedon two bi-directional wires, which negotiate on the state of the dualbuffer between them. Therefore, two bidirectional lines are required toconnect two consecutive layers, i.e. each layer uses four bidirectionallines, two for the previous layer and two for the next layer. The twobackward signals indicate whether the buffer ready for receiving newdata for each one of the two buffers between the layers, and the twoforward signals indicate whether the data in the buffer is valid forboth buffers. To simplify the interface, the controller can flip themeaning of the two buffers (i.e. active and passive) in both directions,using a dedicated instruction.

A high-level block diagram illustrating the inter-cluster crossconnectin more detail is shown in FIG. 12. The inter-cluster interconnectfabric/crossconnect, generally referenced 430, comprises a plurality ofmultiplexers 432 and splitters 440 that enable communications betweenclusters 436. In one embodiment, each cluster J comprises a plurality ofports, including input ports 396 and output ports 398. Four input andoutput ports are shown in the example but any number can be implemented.

Multiplexers 432 on the input side are controlled by SEL lines 438. Theinputs 434 to each multiplexer comprise output lines from neighboringclusters, e.g., clusters J−2, J−1, J, J+1. The output 444 from eachmultiplexer is input to a separate input port 396 in a cluster.Similarly, splitters 440 on the output side generate outputs 442 thatare fed to input lines of neighboring clusters, e.g., clusters J−1, J,J+1, J+2. The output 446 from each output port 398 of a cluster is inputto a separate multiplexer 440. The NN manager 392 functions to controlthe configuration of the crossconnect 430. In one embodiment, thepossible connections from one cluster to another is intentionallylimited to reduce addressing and control routing and to improvebandwidth. For example, connections to cluster J via inputs 434 arelimited to clusters J−2, J−1, J, and J+1, i.e. neighboring clusters (anditself) only. Similarly, connections from cluster J at the outputs 442are limited to clusters J−2, J−1, J, and J+1. Note that although directconnections to other clusters are limited, any cluster is still able tocommunicate with any other cluster indirectly by traversing one or moreintermediary clusters.

Note that the crossconnect occurs at all levels, starting at the clusterlevel, going through the top level of the NN processor core as well asdevice to device. The L clusters in the NN processor are connected usinga cyclic interconnect fabric that enables output ports from one clusterto be mapped to neighboring clusters. The crossconnect is also capableof routing outputs of a cluster to itself (i.e. self-routing). Note thatthe extent of access in the crossconnect is configurable and permits atradeoff between design complexity and accessibility. Note also that ascatter/gather' mechanism allows the outputs to be split (i.e. viasplitters) into multiple replicas such that the same output feedsmultiple inputs in parallel. Control of the crossconnect is provided byNN manager 392 via control lines 431.

Sliding Overlapping Memory Windowing

A diagram illustrating a first example memory windowing scheme is shownin FIG. 13. To maintain flexibility, each consumer of memory in theprocessor has the ability to access different memory segments for theexchange of data. The term memory windowing refers to a scheme whereby acomputing element or entity is given access only to a certain subset ofavailable memory resources rather than a much wider range of memoryresources. Limiting access to memory by the compute elements using amemory windowing scheme significantly improves the available bandwidthwhile greatly reducing the required address and control routing. Notethat the memory fabric can dynamically rearrange the memory windowingscheme whereby the memory resources accessible by compute elements isprogrammable and configurable (e.g., at compile time, runtime, etc.).The windowing scheme is based on a scatter/gather technique described inmore detail infra.

In the example shown, generally referenced 580, two compute elements 582access memory resources 584, 586, 588. None of the compute elements haveaccess to the entire memory, but rather only to a finite window. This isbecause the compute elements never require access to the entire memoryfabric at once. Note that the windowing can different for control,ingress data, egress data, and weights. In addition, the windowstypically overlap to enable sharing and pipelining. Also, the memoryresources themselves is multipurposed where it can be used to store morethan one type of information.

In the illustrative example, control for compute element 1 spans memoryblocks 584, 586, and 588, denoted by Control 1 arrow 590. Computeelement 1 includes an ingress data window to memory block 586, denotedby Ingress Data arrow 592. Similarly, compute element 1 includes anegress data window to memory block 588, denoted by Egress Data arrow594. The weights are stored in memory block 584 as well as in memoryblock 588 which also functions to store egress data. In similar fashion,the other compute elements include control, ingress, egress, and weightwindows as well. For example, compute element 2 includes a controlwindow 596 spanning memory block 588 as well as one or more other memoryblocks (not shown).

A diagram illustrating a second example memory windowing scheme is shownin FIG. 14. In one embodiment, the data that flows through the computingelements in the NN processor is pipelined, wherein PEs in thesubclusters receive data as input and generate outputs which then serveas input for some other subcluster for subsequent computations. Thememory in the various layers is localized as much as possible andleveraged to maximize accessibility and efficiency of the computingelements each layer serves. Since the computing elements only need toaccess a limited subset of the memory routing (i.e. address lines,control, etc.) can be limited to cross connect memory blocks andcomputing elements that are actually needed. FIGS. 15, 16, and 17illustrate the configurability of the memory access windows throughwhich the allocation of each resource is administered and configured andequipped with the resources that address the particular demand.

The window memory scheme, generally referenced 340, comprises aplurality of subclusters 348, each including a plurality of PEs 349, L3memory (not shared) 342, and L3 memory (shared) 344. In operation, thesubclusters receive weights information 345 from a portion of L3 memorythat is not shared. Input data 341 to a subcluster is received from anallocated memory block 346 from a shared portion of L3 memory. The PEswithin the subcluster process the weights and input data and generateoutputs 343. The outputs, however, are written to a different (e.g.,neighboring) allocated memory block (i.e. not the memory block theinputs were read from). These outputs are then read as inputs to anothersubcluster (e.g., neurons in a subsequent layer of the ANN). In thisfashion, ANN input data 347 enters shared L3 memory, is read fromallocated memory blocks, processed by the PEs in one or moresubclusters, output to neighboring memory blocks, and after traversingthrough the various layers in the ANN is ultimately output as ANN outputdata 349 from shared L3 memory.

Note that the subclusters, however, do not have direct random accesscapability to L3 memory, but rather only to neighboring or close byallocated memory blocks. For example, subcluster H has access tosubcluster H−2, H−1, H (itself), and H+1 subclusters. This greatlyreduces the addressing and control routing requirements for memoryaccess. Thus, each subcluster only ‘sees’ a relatively small window ofmemory, just enough for its PEs to perform their function.

A diagram illustrating first example memory accessibility betweencompute and memory elements window size and computer accessconfigurability is shown in FIG. 15. This diagram illustrates the memorywindowing scheme whereby compute elements as well as memory elementshave limited access to each other. For example, consider memory elements1 through D and compute elements 1 through E. The hatched blocked area520 represents the resources accessible by each. Thus, the computeelements 1 through 3 can only access memory elements 1 through 12.Similarly, memory elements 1 through 12 can only connect to computeelements 1 through 3. As shown, the memory elements accessible to thecompute elements form sliding access windows that overlap one another.The access windows have a size (i.e. span) and specific connectivitythat can be dynamically configured and not hardwired or fixed. A keyfeature is that any single compute element does not have random accessto the entire memory. Rather, each compute element can only access aportion of the memory elements, e.g., neighboring memory elements orthose close by. The non-accessible portion of memory for the computeelements is represented by the white area 522.

Note also that the number of compute elements accessible by memory isprogrammable and configurable as represented by the vertical arrows 523.Similarly, the number of memory elements accessible by a compute elementis programmable and configurable as represented by the horizontal arrows521.

A diagram illustrating second example memory accessibility betweencompute and memory elements is shown in FIG. 16. This diagramillustrates that access between compute and memory elements is notlimited to contiguous windows. Rather, access may be discontinuous whichis achieved in one embodiment using virtual to physical mapping.Regardless of the means, the accessible regions have rectangular shapesof limited and predefined range indicating that access between computeand memory elements is limited and finite i.e. no such region covers theentire address space.

A diagram illustrating an example scatter/gather based resourcewindowing technique is shown in FIG. 17. For illustration purposes, aportion of an example cluster 530 is shown. The technique, however, isnot limited for use in a cluster and can be used anywhere in the NNprocessor. Consider two resources A 532 and B 538, where the resourcemay comprise any desired circuit, e.g., compute, memory, controlelements, etc. To limit access, the output of each resource A 532 isinput to a splitter 534 and the input to each resource B 538 is theoutput of a multiplexer 536. Rather than provide full mesh connectivity,the outputs of the splitters only go to a limited number of multiplexerinputs, thus providing limited connectivity. For example, the output ofresource A1 is input to resources B1 and B2 only. Similarly, the outputof resource A2 is input to resources B1, B2, and B3 only and the outputof resource A3 is input to resources B2 and B3 only. In this manner,each B resource only connects to a small window of A resources. Thus,access between the 100 A resources and 50 B resources (the number ofresources is only an example) forms a sliding window where a finitenumber of A resources connect with a finite number of B resources on anoverlapping sliding basis.

Control of the splitters and muxes is provided by the layer controllers(LCs) 548. The control lines 549 output of the LCs are input to a seriesof muxes 546 in a control fabric 544 that select one of the controlsfrom the LC in accordance with a SEL line 547 which originates in theLCU and may be further decoded within the LC. The control of the muxes546 is programmable and configurable, such as at compile or run time,thereby achieving flexible mapping between the A and B resources.

In accordance with the invention, a feature of the memory access fabricof the NN processor is the ability to operate in substantially highparallelism. This is a virtue of the inherent separation of mappingsbetween compute resources and the memory attached to them. For example,weights are connected explicitly only to the relevant subcluster. Oneexception, however, is the case where an allocated memory block isshared and a collision occurs. Although such an event is typically rare,the NN processor provides the capability to resolve the contentionresulting from the collision. In one embodiment, memory contention isresolved at the control layer, where the two compute entities that sharea common memory block handle collision avoidance at the signaling levelas described infra. Note that backpressure is typically temporary andshort lived, and the overall total bandwidth is guaranteed by the designof the NN processor.

A block diagram illustrating an example memory contention resolutionscheme is shown in FIG. 18. Memory contention resolution circuit,generally referenced 600, comprises L3 memory 602 including a pluralityof memory blocks 632, MMU 626, LCU A 604, LCU B 606, one or moresubclusters 618 forming ANN layer G 614, and one or more subclusters 620forming ANN layer G+1 616.

In this illustrative example, both layers G and G+1 of the ANN read andwrite data to and from memory blocks 634 in L3 memory. The output oflayer G serves as the input to layer G+1. Occasionally, however, bothlayers may try to access the same memory block at the same time. This isindicated by the memory block 636 labeled with an ‘X’. When contentionfor the same memory block occurs, the MMU 626 detects the event andgenerates a contention alert 608 to the LCUs (A and B in this example)in their respective LCs. In response to the contention alert, one of theLCUs generates a halt command 610, 612 that is input to the subclusters.The subcluster that receives the halt command inhibits access to thememory block in L3 memory until the read or write operation is complete.

Note that memory contention always occurs between ANN layers and notwithin a layer since within a layer, the subcluster making up the layerare configured such that contention for memory never occurs. Typically,contentions occur when one layer is writing while the other is reading.In response to the contention alert, either the write or the readoperation can be inhibited. In one embodiment, the write operation isinhibited since the nature of ANNs is that write operations are farrarer events. In addition, inhibiting read operations would stall asignificant portion of the data processing pipeline. Thus, writeoperations are inhibited rather than read operations. A halt signal (610to layer G or 612 to layer G+1) is issued to the layer to be inhibited.Note also that the decision whether to inhibit write or read operationsis programmable and configurable a priori at compile time.

Layer Controller

A high-level block diagram illustrating an example layer controller inmore detail is shown in FIG. 19. The layer controller (LC), generallyreferenced 310, comprises a layer control unit (LCU) 314 responsible fordecoding and executing microcode instructions 311 read from instructionmemory 312. Depending on the instruction one or more command signals 313are output to various control and decode blocks, including input alignercontrol 316, activation control 318, input address decoder 320, weightaddress decoder 322, output address decoder 324, and PE control 326. Thecontrol and address signals from these six blocks are respectivelyoutput to input aligner 328, activation function circuit 330, inputmemory 332, weight memory 334, output window 335, and control window336. PE control signals 315 are output from the control window 336 tothe PE circuits in the subclusters 338.

A high-level block diagram illustrating the layer controller interfaceto L3 memory and subclusters in more detail is shown in FIG. 20. Theexample cluster, generally referenced 640, comprises L3 memory 644, LC642, plurality of subclusters 662, post processor 666, and windowing forcontrol, write data, read data, and weights as described supra inconnection with FIG. 17. The LC 642 comprises LCU 656, one or morepreprocessors 652, instruction memory 654, one or more decoder circuits658, and MMU 660.

In particular, control windowing includes circuit 674 and control lines684; weight windowing includes circuits 646, 648, and signal lines 650;ingress data windowing includes circuits 676, 678, 672, and signal lines690, 692; egress data windowing includes circuits 680, 682, 668, andsignal lines 686, 688. Note that the ingress and egress windowsaccessing L3 memory overlap as indicated by the dashed lines. Controlfor the windowing (i.e. selects for the splitters and muxes) is providedby the memory window control (MWC) signals 670 generated by the LCU anddecoders and input to the window circuits 674, 646, 648, 676, 678, 672,680, 682, and 668.

In operation, ingress data is read from L3 memory and input to thepreprocessing circuits 652. These circuits function to optionallyreshape the data, performing manipulations on the input data, e.g.,shifting, etc. The preprocessed data is output to the subclusters wherethe PEs 664 multiply the input data with weights also read from L3memory. Intermediate results, i.e. contexts, are output from thesubclusters to post processing circuitry 666 through the memorywindowing. The post processing circuit is part of the data processingpipeline and is operative to apply the activation function andoptionally alignment.

Note that each LC is assigned one or more subclusters that make up alayer in the ANN. Each cluster comprises a plurality of LCs (e.g.,eight). Thus, the subclusters 662 shown are only a subset of the Msubclusters within each cluster, where each LC controls a different setof subclusters that can be selected using the same windowing conceptdescribed above. In addition, the N PEs within a subcluster are notsplit, meaning all PEs in a subcluster are controlled as a single unit.This simplifies the control of the computing elements and allows forrelatively lean control signaling as only a few control lines controllarge numbers of PEs and ultimately neurons. Similarly, each of thedecoder circuits 658 is configured to control a different set of memoryblocks. The control signals 698, which in one embodiment are encoded,are generated by the LCU and input to the decoders circuits 658. The LCUitself is controlled by the contents of the instruction memory 654. Theexecution of each instruction results in the generation of encodedcontrol signals which are then decoded by the decoders and output to thecomputing elements via the control window circuit 674. Note that inaddition to the control signals that control the computing elements inthe subclusters, the LCU also generates the control signals (i.e. MWCselect controls) for controlling the control window as well (along withthe weight, ingress and egress data windows). Once configured (ascompile time), the control signals, weights, ingress and egress data arerouted statically. The MMU 660 generates the control signals for the L3memory windowing and functions to perform the virtual to physicalmapping. It also functions to generate a contention alert 694 inresponse to a memory contention event between two layers in the ANN. Asdescribed supra, the LCU resolves the contention event by issuing one ofthe layers a halt command.

A high-level block diagram illustrating a second example layercontroller in more detail is shown in FIG. 21. The example LC, generallyreferenced 550, comprises instruction memory 552 including a pluralityof instructions 554, LCU 556, instruction decoders 566, trigger windowcrossconnect 558, and trigger handler 560. The LCU 556 comprises a statemachine 562, and instruction register 564.

In operation, instructions 551 are read from instruction memory into theinstructions register 564 in the LCU where they are decided andexecuted. The one or more portions 568 of the instruction that areconfigured to directly control hardware are sent to the one or moredecoders 566 for decoding. The output of the decoders comprises directcontrol signaling that is sent to the subclusters to control theinternal PE operation as shown and described supra in FIG. 20. The otherportions 570, 572 of the instruction control the logical state of theLCU and are input to the state machine 562. These portions controllooping and branching, for example. A next 553 command causes the nextinstruction from the instruction memory 552 to be read into the LCU forexecution.

In one embodiment, one or more triggers 555 are generate by the statemachine and input to the trigger crossconnect 558. The trigger functionis similar to an ‘interrupt’ where activity can be halted and delayeduntil the occurrence of some event. Trigger signals are used to triggeractivity. Triggers can be issued to activate other triggers. Theyrepresent an asynchronous mechanism that functions to synchronizeactivities in the NN processor. For example, a trigger can be issued tohalt processing until a buffer is written to, or until a layer completesprocessing (or otherwise function as an indication that some event hastaken place and further processing can commence).

In addition, a trigger can be issued to trigger activity in an LCU in adifferent LC. This process is termed a ‘handover’. The handovermechanism can trigger activity from one LC to another, e.g., a triggercan be used when one ANN layer completes and sends results to anotherlayer in the ANN. The trigger window crossconnect, functions to steeroutput trigger signals 559 to the trigger handler in the appropriate LCwhere they act to control activity in the LCU via signals 557.

Regarding the separation between data and control planes, in oneembodiment, the microcode that governs the control plane executes in theLCs and does not have any access to data. An additional capability ofthe microcode machine in the LCs is that there are no conditionalstatements or conditional branching. This is advantageous for datapipelining since the need to manage branch prediction or other pipelineoverhead is avoided. Execution is thus fully predictable. This is incontrast to typical prior art microcode that can branch causingexecution to be dependent on the input. In the NN processor, oncemicrocode executes, the evolution of data flow is fully predictable,i.e. the generation of each control signal can be predicted at everyinstance in time.

In one embodiment, each microcode instruction executed in themicrocode-based controllers is operative to generate control signalingfor compute resources and memory resources. In other words, themicrocode does not carry any ‘overhead’ as there are no operations thatare responsible for internal handling that do not also apply actualcontrol signaling to the outputs. Thus, no microcode instructionoperations are wasted on internal housekeeping of the microcode machine(with the sole exception of a ‘NOP’ operation).

Another capability of the microcode machine in the LCs is triggeredoperation. Although branching is not supported, execution flow can betriggered by external signals that indicate start/stop of execution toenable data pipeline handshakes, e.g., handoffs from one LCU to another.

Yet another capability of the microcode machine in the LCs is repeatedoperation support whereby inline repetition of operations (i.e. loopsthat run inline) are supported such that repeated operations can beindicated within the opcode itself thereby avoiding unnecessary cyclesfor setting up and managing the loop, and related fetching. Note thatthis feature is useful for loops that have few operations compared tothe overhead of loop management. The latter is very common in neuralnetwork operations, e.g., many multiple and accumulate (MAC) operationsfollowed by activation. In a data pipeline machine, it is very importantwhen the ratio between control and data is such that very little controldefines the behavior of a relatively large data pipe.

For example, consider a conventional processor configured to perform1000 multiply and accumulate (MAC) operations. Example pseudo code isprovided in Listing 2 below.

Listing 2: Example conventional processor pseudo code loop Init: Setcount = 1000 Start: Multiply A, B => C Add C, D Decrement count by 1 Ifcount > 0 jump to Start

In the above pseudo code, there are four opcodes in the loop (i.e. fourcycles) two of which are operational, for a utilization of 50%. Assumingthat this loop controls 1024 MAC circuits, this means that only 512 areeffectively operating at full capacity.

In contrast, inline repetition is supported in the NN processor. Inaddition, there is zero overhead for internal control eliminating therequirement to have ‘spare’ opcodes, i.e. opcodes that are used just forinternal management of the machine or housekeeping. The pseudo code ofListing 2 translates into the following pseudo code presented below inListing 3.

Listing 3: Example NN processor pseudo code loop Mul a, b => c; startloop Add c, d; end loop, 1000 repetitions

As shown above, all loop information is embedded in the functionalopcodes and MAC utilization increases to 100%.

It is noted that having a deep separation between control and dataplanes also functions to provide a degree of inherent immunity fromcontrol plane security hazards. This is because a common technique forhacking a device is to feed it data that interferes with the controlplane. Since the two planes are strictly separate, interfering with onedoes not affect the other.

Compiler

A high-level block diagram illustrating an example NN processorcompiler/SDK is shown in FIG. 22. The compiler, generally referenced770, functions to configure the NN processor based on an input ANNmodel. It is executed in a process that executes off-chip as part of anexternal software tool chain used and initiated by a user. Typically,the compiler has knowledge of the NN processor, NN processor SoC ormultiple NN processor SoCs that will be the target of the source ANNmodel.

In particular, the translator 772 functions to receive the user modeland generate an intermediate format of the model. The optimizer 774functions to perform model level optimizations, post-translation modeladjustments for performance, and numerical adaptations to different bitwidths. The resource allocator 778 allocates and assigns physicalresources (e.g., compute and memory elements, etc.) in accordance withthe intermediate model. The profiler 786 performs a performanceevaluation, including for example, expected power consumption,throughout, latency, etc. The software emulator 782 functions to performbit exact numerical emulation of the NN processor using the intermediatemodel output of the translator 772.

In one embodiment, several target options are provided to the user toimplement the external tool chain. The three target options include (1)the NN Device 780, (2) emulator 782, and (3) simulator 784 whichcomprises a software model of the hardware that simulates NN devicefunctionality. Thus, a user has the option of executing the tool chaineither using the NN device itself, a hardware emulation of the NN deviceor a software simuilation of the NN device.

Multiple Operating Granularity of the NN Processor and RelatedMemory/Latency Trade-Off

A capability and advantage of the present invention is that the pipelinein the NN processor is able to operate at any desired granularity of anysubset of the input where memory is traded off for latency and viceversa. More specifically, when the input data has some internalstructure (e.g., frames of video and each frame is composed of multiplerows (or buffers, packets, etc.), the NN processor architecture cantrigger the activity of a next layer at any aggregation from a singlesuch row, buffer, packet, etc. multiples of thereof.

In the case of lower aggregation, additional intermediate result (i.e.contexts) storage is required to store the intermediate results.Latency, however, is minimal since subsequent processing elements arefreed up for further processing earlier in the pipeline, which allowsincoming traffic to be consumed but not become blocked. Thus, highermemory storage requirements are traded-off for lower latency ofcontexts.

On the other hand, in the case of higher aggregation, i.e. less contextmemory is desired or an ANN model that requires large numbers ofcontexts is to be implemented, a trade-off can be made where lesscontext memory is used in exchange for buffer memory whereby additionalbuffering of the input is implemented resulting in a decrease of thenumber of contexts needed simultaneously at any one time, but with anincrease in latency. In one embodiment, this trade-off is implemented bymicrocode in the LCs and is thus configurable and programmable.

A diagram illustrating the flexible processing granularity of the NNprocessor and related memory versus latency trade-off is shown in FIG.23. The data pipeline example, generally referenced 930, highlights theoption of leveraging the data pipeline to favor minimal latency andoperate at low input domain granularity. Consider the example inputtensor 932 including input data 938 that can be located at the beginningof or at any arbitrary point in the network. One of the network layersthen applies an NN operation 934 to the input data (e.g., 3×3convolution in this example) followed by the output domain 936 includingmemory blocks 931 and 939.

In this example, the input data stream is fully consumed and all neededcalculations are applied while minimizing latency and without the needto retrieve the input data since all computations are committed tointermediate results stored in memory. In alternative embodiments, thisfunction can be executed by: (1) waiting for the entire frame andapplying a batch operation whereby all data is immediately committed tooutput to avoid intermediate results; (2) waiting for the minimal set ofrows in order to avoid intermediate results (in this example casethree); (3) using intermediate results stored in external memory withthe increase in memory access latency; or (4) recalling inputs as needed(i.e. multiple reads of the same data) in order to avoid having to storeintermediate results.

NN Processor SoC, Intra-Chip and Inter-Chip Connectivity

As described in detail supra, the NN processor can be used to implementan ANN. In the event, however, that the ANN to be implemented exceedsthe capacity of the NN processor, the invention provides the capabilityof using several NN processors to implement the ANN model. As describedsupra, the NN processor comprises a plurality of bus interfaces (e.g.,chip to chip interfaces) for communicating between NN processor cores.In the example disclosed herein, two chip-to-chip interfaces areprovided, but any number can be implemented. Thus, large ANN models canbe accommodated by combining the processing power of multiple NNprocessor cores.

It is noted that deployment of a network of interconnected NN processorsover the chip to chip interfaces is substantially seamless. Utilizingdevice-to-device communications, the behavior of the network isequivalent to an ANN contained on a single NN device. In one embodiment,the chip-to-chip interface keeps with the technique of narrowingbandwidth on the boundaries of layers. The physical layer of theinterface may comprise any suitable protocol that is synchronous andguarantees the required bandwidth. The next layer is a packet layerwhich carries a frame format that can be removed by the receiving chip.The structure of the frame format attempts to minimize overhead intransition between devices and is similar to that of Ethernet, includinga plurality of fields including, for example, a stream ID, destinationlayer, data format, etc. For example, consider a layer having a W×H×Foutput tensor. The protocol identifies the structure, the stream ID, andnetwork ID in the next device before any processing occurs. Thebandwidth needed is then (W×H×F+overhead)×frames/s.

A diagram illustrating a first example multi-NN processor SoC system ofthe present invention is shown in FIG. 24. In one embodiment, the NNprocessor core (or engine) as described supra and shown in FIGS. 4 and 5can be replicated and implemented as a System on Chip (SoC). Theintellectual property (IP) for the NN processor core can be used toimplement a monolithic integrated circuit (IC). Alternatively, physicalNN processor core dies can be integrated and implemented on an SoC.

Implemented as a monolithic semiconductor or an SoC, the NN processorSoC, generally referenced 700, comprises a plurality of NN processorcores 706 interconnected via an internal bus 710, one or more externalinterface circuits 702, one or more ‘external’ L5 memory circuits 708,bootstrap and preprocess circuit 704, and postprocess circuit 712. Notethat the number of NN processor cores, L5 memory circuits, etc. is notlimited to that shown as one skilled in the semiconductor arts canimplement an IC or SoC having any number of NN processor cores and othercomponents.

In operation, ANN input data 714 is written to the SoC 700 via anexternal I/F 702. The bootstrap and preprocess circuit 704 is operativeto perform one or more functions depending on the implementation,including for example, buffering, clocking, power management, datathrottling, etc. Data is then fed to the NN processor cores 706 forprocessing. The NN processor cores communicate with each other over theinternal bus 710. Note that connectivity between the NN processor coresmay comprise any desired routing type including such as full mesh, tokenring, chained, etc. depending on implementation and is not critical tothe invention. Note that the other circuit components also communicateover the bus, including the bootstrap and preprocessor 704, externalI/Fs 702, L5 memories 708, and postprocessor 712.

A diagram illustrating a second example multi-NN processor SoC system ofthe present invention is shown in FIG. 25. In this example system,generally referenced 790, a plurality of NN processor cores or SoCs 794are concatenated serially. ANN input data 792 enters the left most NNprocessor and ANN output data 799 exits the right most NN processor. Theplurality of NN processors together implement the ANN model layer bylayer.

A diagram illustrating a first example multi-NN processor SoC system ofthe present invention is shown in FIG. 26. In this example system,generally referenced 800, three NN processor cores or SoCs 804, 806, 808are combined in a 2->1 gather scheme and together implement the ANNmodel. ANN input data 802 is input to both NN processors 804, 806through input ports. In this example, two NN processor cores 804, 806 inparallel are needed to implement the ANN model, e.g., either (1) themodel contains a very large number of neurons in one or more layers or(2) the number of neurons exceeds any of the resource constraints (e.g.,control, memory or compute) of a single device. The outputs of each NNprocessor 804, 806 are input via chip to chip input ports to NNprocessor 808 which functions to generate the ANN output 809.

A diagram illustrating a first example multi-NN processor SoC system ofthe present invention is shown in FIG. 27. In this example system,generally referenced 810, three NN processor cores or SoCs 814, 816, 818are combined in a 1→2 scatter scheme and together implement the ANNmodel. ANN input data 812 is input to NN processor 814 through an inputport. The output of NN processor 814 is input to both NN processors 816,818. In this example, two NN processor cores 816, 818 in parallel areneeded to implement the ANN model, e.g., either (1) the model contains avery large number of neurons in one or more layers or (2) the number ofneurons exceeds any of the resource constraints (e.g., control, memoryor compute) of a single device. The outputs generated by each NNprocessor 816, 818 are combined to form the ANN output 819.

Example ANN Mapping Strategies

As described supra, if the requirements of an ANN exceed the computeand/or memory resources of a single NN processor core, the ANN model canbe split across several devices. The compiler/SDK seamlessly leveragesthe typically cellular nature of ANNs that allows splitting and mergingbetween and across network layers. Within the compiler, the split isdone while accounting for the bandwidth demand at the input and outputof the sub-networks that are mapped to each device, in addition torelying on the fact that inter-layer bandwidth is inherently much lowerthan intra-layer bandwidth. Several example mapping possibilities andstrategies are presented.

Generally speaking the device to device mapping, as performed by thecompiler, is driven by the number of input and output ports present inthe device (e.g., two in the present example). In the example case oftwo input and output ports on the device, the flexibility to map 1→2(i.e. scatter), 2→1 (i.e. gather), as well as 1→1 (i.e. feedforward)allows constructing the system arrangements shown.

A diagram illustrating an example mapping strategy for the first exampleANN of

FIG. 2 is shown in FIG. 28. As described supra, the compiler/SDKfunctions to map the logical ANN model to the physical NN processordevice. As a result of its analysis, in this example, the compilerdetermines that the entire ANN can be implemented in a single cluster362 in a single NN processor device. Each network layer 365 in the ANNis mapped to one or more subclusters 364 and an LC 361 is assigned aswell. Thus, for example, network layer 1 is mapped to three subclusters,namely subclusters 1, 2, and 3 which also receive ANN inputs 363. Thesethree subclusters are configured and controlled by LC 1. Similarly, theneurons in network layer 2 are mapped by the compiler to subclusters 4,5, and 6 and assigned to LC 2. The neurons in network layer 3 are mappedto subclusters 7 and 8 and assigned to LC 3. Finally, network layer 4 ismapped to subcluster 9 and configured and controlled by LC 4. The ANNoutputs 369 are generated by subcluster 9.

A diagram illustrating a second example artificial neural network isshown in FIG. 29. This example ANN, generally referenced 720, which maybe a convolutional type NN, comprises a plurality of layers 726,including Layers 1 through 6. Layer 1 receives ANN input 722 and Layer 6generates ANN output 724.

A diagram illustrating an example multi-NN processor SoC system of theANN of FIG. 29 is shown in FIG. 30. The NN system, generally referenced730, represents the mapping of the ANN 720 to the NN processor system ofthe present invention. Each NN processor 736 comprises a separate IC oralternatively, a separate die in an SoC.

It is the function of the compiler and SDK to map the logical ANN modelto physical NN processor configuration during the complication process.In this example, Layer 1 maps into the entire NN processor 1 since itscapacity in terms of compute elements, memory fabric, etc. is onlysufficient to implement Layer 1. NN processor 1 also received the ANNinput 732. Layers 2 and 3 are such that they cannot be implemented in asingle device, thus two devices are required, i.e. NN processors 2 and3, in parallel and the processing is split between them. Layer 4 islarge but the compiler determines that it can be implemented in a singledevice. Thus, the entire NN processor 4 is mapped to Layer 4. Layers 5and 6 are analyzed and mapped to a single NN processor 5 device by thecompiler. NN processor 5 generates the ANN output 734. Note that the NNprocessors communicate with each other in a feedforward manner via thechip to chip interfaces in each device.

A diagram illustrating a third example artificial neural network isshown in FIG. 31. The example ANN, generally referenced 740, is intendedto represent any desired ANN. It comprises a plurality of neurons 744organized into different network layers. Input data X 746 is input tothe first layer and output data Y 748 is generated by the last layer.

A diagram illustrating a first example multi-NN processor SoC system ofthe ANN of FIG. 31 is shown in FIG. 32. In this example, a firstmapping, generally referenced 750, is generated by the compiler/SDK andcomprises several NN processor devices. In particular, the neurons 756in the first two network layers are mapped to NN processor 1, the thirdnetwork layer is mapped to NN processor 2 and the last three networklayers are mapped to NN processor 3. ANN input data 752 is input to thefirst layer in NN processor 1. NN processor 3 generates the ANN outputdata 754.

A diagram illustrating a second example multi-NN processor SoC system ofthe ANN of FIG. 31 is shown in FIG. 33. In this example, a differentmapping, generally referenced 760, is generated by the compiler/SDK andcomprises several NN processor devices. In particular, the neurons 766in the first four network layers are split between two devices, namelyNN processors 1 and 2, as they exceed the capacities of a single device.The last two network layers are mapped to NN processor 3. ANN input data762 is input to the first layer in NN processors 1 and 2. NN processor 3generates the ANN output data 764.

Those skilled in the art will recognize that the boundaries betweenlogic and circuit blocks are merely illustrative and that alternativeembodiments may merge logic blocks or circuit elements or impose analternate decomposition of functionality upon various logic blocks orcircuit elements. Thus, it is to be understood that the architecturesdepicted herein are merely exemplary, and that in fact many otherarchitectures may be implemented which achieve the same functionality.

Any arrangement of components to achieve the same functionality iseffectively “associated” such that the desired functionality isachieved. Hence, any two components herein combined to achieve aparticular functionality may be seen as “associated with” each othersuch that the desired functionality is achieved, irrespective ofarchitectures or intermediary components. Likewise, any two componentsso associated can also be viewed as being “operably connected,” or“operably coupled,” to each other to achieve the desired functionality.

Furthermore, those skilled in the art will recognize that boundariesbetween the above described operations merely illustrative. The multipleoperations may be combined into a single operation, a single operationmay be distributed in additional operations and operations may beexecuted at least partially overlapping in time. Moreover, alternativeembodiments may include multiple instances of a particular operation,and the order of operations may be altered in various other embodiments.

The terminology used herein is for the purpose of describing particularembodiments only and is not intended to be limiting of the invention. Asused herein, the singular forms “a”, “an” and “the” are intended toinclude the plural forms as well, unless the context clearly indicatesotherwise. It will be further understood that the terms “comprises”and/or “comprising,” when used in this specification, specify thepresence of stated features, integers, steps, operations, elements,and/or components, but do not preclude the presence or addition of oneor more other features, integers, steps, operations, elements,components, and/or groups thereof.

In the claims, any reference signs placed between parentheses shall notbe construed as limiting the claim. The use of introductory phrases suchas “at least one” and “one or more” in the claims should not beconstrued to imply that the introduction of another claim element by theindefinite articles “a” or “an” limits any particular claim containingsuch introduced claim element to inventions containing only one suchelement, even when the same claim includes the introductory phrases “oneor more” or “at least one” and indefinite articles such as “a” or “an.”The same holds true for the use of definite articles. Unless statedotherwise, terms such as “first,” “second,” etc. are used to arbitrarilydistinguish between the elements such terms describe. Thus, these termsare not necessarily intended to indicate temporal or otherprioritization of such elements. The mere fact that certain measures arerecited in mutually different claims does not indicate that acombination of these measures cannot be used to advantage.

The corresponding structures, materials, acts, and equivalents of allmeans or step plus function elements in the claims below are intended toinclude any structure, material, or act for performing the function incombination with other claimed elements as specifically claimed. Thedescription of the present invention has been presented for purposes ofillustration and description, but is not intended to be exhaustive orlimited to the invention in the form disclosed. As numerousmodifications and changes will readily occur to those skilled in theart, it is intended that the invention not be limited to the limitednumber of embodiments described herein. Accordingly, it will beappreciated that all suitable variations, modifications and equivalentsmay be resorted to, falling within the spirit and scope of the presentinvention. The embodiments were chosen and described in order to bestexplain the principles of the invention and the practical application,and to enable others of ordinary skill in the art to understand theinvention for various embodiments with various modifications as aresuited to the particular use contemplated.

What is claimed is:
 1. A neural network (NN) processing element circuitfor use in a NN processor for performing neural network calculations foran artificial neural network (ANN) having one or more network layers,comprising: a multiplier operative to receive weight and input data andto generate a product therefrom; an adder operative to receive and sumsaid product and a current context to generate an updated contexttherefrom; a local memory coupled to said adder and operative to storesaid updated context therein; and wherein individual storage locationsin said local memory are accessed in a predefined manner other thanrandomly.
 2. The circuit according to claim 1, wherein each storagelocation in said local memory represents at least one neuron in the ANN.3. The circuit according to claim 2, further comprising circuitryoperative to implement a plurality of logical neurons in a single neuronin said local memory, wherein each context represents the output of asingle neuron, and wherein said logical neurons are time-multiplexedwherein each location in said local memory represents different neuronsfrom a plurality of neurons at different times.
 4. The circuit accordingto claim 1, wherein said local memory has a depth that reflects a numberof simultaneous contexts the processing element can implement in aspatial domain.
 5. The circuit according to claim 4, wherein theprocessing element can implement additional contexts in said localmemory in a time domain by swapping out the contents thereof to memorylocated in a higher aggregation level.
 6. The circuit according to claim1, further comprising a first representation circuit operative to formatweight and/or input data as integer or floating point representationbefore input to said multiplier.
 7. The circuit according to claim 1,further comprising a second representation circuit operative to formatproducts generated by said multiplier as integer or floating pointrepresentation before input to said adder.
 8. The circuit according toclaim 1, wherein said local memory is located within said processingelement and dedicated for use therewith.
 9. The circuit according toclaim 1, further comprising a first multiplexer circuit operative toselect between said current context stored in said local memory or acontext stored in memory located in a higher aggregation level for inputto said adder.
 10. The circuit according to claim 1, further comprisinga second multiplexer circuit operative to select between said updatedcontext generated by said adder or a context stored in memory located ina higher aggregation level to be stored in said local memory.
 11. Thecircuit according to claim 1, further comprising a third multiplexercircuit operative to select between a function located at a higheraggregation level, memory located in a higher aggregation level, or saidlocal memory to write said updated context generated by said adder. 12.The circuit according to claim 1, further comprising a plurality ofmultipliers and circuitry operative to combine two or more multiplierscapable of performing higher precision multiplications compared to asingle multiplier.
 13. The circuit according to claim 1, furthercomprising a quad circuit that combines four multipliers to yield adouble precision processing element circuit.
 14. A neural network (NN)processing element circuit for use in a NN processor for performingneural network calculations for an artificial neural network (ANN)having one or more network layers, comprising: a plurality ofmultipliers operative to multiply received weight and input data togenerate a product therefrom; an accumulator operative to add saidproduct with a current context received from either a local memory ormemory located at a higher aggregation level to generate an updatedcontext therefrom; said local memory coupled to said accumulator andoperative to store said updated context therein in sequential fashion; amultiplexer operative to write said updated context to either said localmemory, said memory located at a higher aggregation level, or to afunction located at a higher aggregation level, in accordance with aselect control signal; and wherein individual storage locations in saidlocal memory are accessed in a predefined manner other than randomly.15. The circuit according to claim 14, wherein each storage location insaid local memory represents at least one neuron in the ANN.
 16. Thecircuit according to claim 14, wherein the processing element canimplement additional contexts in said local memory in a time domain byswapping out the contents thereof to memory located in a higheraggregation level.
 17. The circuit according to claim 14, furthercomprising a first representation circuit operative to format weightand/or input data as integer or floating point representation beforeinput to said adder.
 18. The circuit according to claim 14, furthercomprising a second representation circuit operative to format productsgenerated by said multiplier as integer or floating point representationbefore input to said adder.
 19. The circuit according to claim 14,further comprising a quad circuit that combines four multipliers toyield a double precision processing element circuit.
 20. A methodimplemented by an integrated circuit (IC), the IC including a neuralnetwork (NN) processing element circuit for use in a NN processor forperforming neural network calculations for an artificial neural network(ANN) having one or more network layers, the method comprising:multiplying ANN weight and input data to generate a product therefrom;summing said product and a current context to generate an updatedcontext therefrom; storing said updated context in a memory local anddedicated to the processing element circuit; and wherein individualstorage locations in said local memory are accessed in a predefinedmanner other than randomly.
 21. The method according to claim 20,wherein each storage location in said local memory represents at leastone neuron in the ANN.
 22. The method according to claim 21, furthercomprising time-multiplexing said neurons in said local memory, whereineach location represents a different neuron from a plurality of neuronsat different times.
 23. The method according to claim 20, furthercomprising implementing additional contexts in said local memory in atime domain by swapping out the contents thereof to memory located in ahigher aggregation level.
 24. The method according to claim 20, furthercomprising formatting weight and/or input data as integer or floatingpoint representation before said multiplication.
 25. The methodaccording to claim 20, further comprising formatting said product asinteger or floating point representation before said summing.
 26. Themethod according to claim 20, further comprising selecting between saidcurrent context stored in said local memory or a context stored inmemory located in a higher aggregation level for input to said summing.27. The method according to claim 20, further comprising selectingbetween said updated context generated by said summing or a contextstored in memory located in a higher aggregation level to be stored insaid local memory.
 28. The method according to claim 20, furthercomprising selecting between a function located at a higher aggregationlevel, memory located in a higher aggregation level, or said localmemory to write said updated context generated by said summing.
 29. Themethod according to claim 20, further comprising combining fourmultiplier circuits to yield a double precision processing elementcircuit.
 30. A method implemented by an integrated circuit (IC), the ICincluding a neural network (NN) processing element circuit for use in aNN processor for performing neural network calculations for anartificial neural network (ANN) having one or more network layers, themethod comprising: receiving a first operand, a second operand, and athird operand; dividing operation of said processing element circuitinto time slots; performing computations involving said first operand,said second operand, and said third operand to generate an updated dataelement therefrom; storing said data element in a memory local anddedicated to the processing element circuit; wherein individual storagelocations in said local memory are accessed in a predefined manner otherthan randomly; and wherein data elements are time-multiplexed with eachlocation in said memory representing different data elements from aplurality of data elements at different times.